maxframe 2.2.0__cp312-cp312-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

@@ -0,0 +1,111 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, OutputType
+from ...serialization.serializables import BoolField
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+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"
+
+    bias = BoolField("bias", default=None)
+    fisher = BoolField("fisher", default=None)
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        skipna, bias, fisher = op.skipna, op.bias, op.fisher
+        return KurtosisReductionCallable(
+            func_name="kurt", kwargs=dict(skipna=skipna, bias=bias, fisher=fisher)
+        )
+
+
+def kurt_series(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    bias=False,
+    fisher=True,
+    method=None,
+):
+    op = DataFrameKurtosis(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        bias=bias,
+        fisher=fisher,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def kurt_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    numeric_only=None,
+    bias=False,
+    fisher=True,
+    method=None,
+):
+    op = DataFrameKurtosis(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        numeric_only=numeric_only,
+        bias=bias,
+        fisher=fisher,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/max.py

@@ -0,0 +1,65 @@
+# 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 .core import DataFrameReduction, DataFrameReductionMixin
+
+
+class DataFrameMax(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.MAX
+    _func_name = "max"
+
+    @property
+    def is_atomic(self):
+        return True
+
+
+def max_series(df, axis=None, skipna=True, level=None, method=None):
+    op = DataFrameMax(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def max_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameMax(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)
+
+
+def max_index(df, axis=None, skipna=True):
+    op = DataFrameMax(
+        axis=axis,
+        skipna=skipna,
+        output_types=[OutputType.scalar],
+    )
+    return op(df)

maxframe/dataframe/reduction/mean.py

@@ -0,0 +1,63 @@
+# 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 .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+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
+        return MeanReductionCallable(func_name="mean", kwargs=dict(skipna=skipna))
+
+
+def mean_series(df, axis=None, skipna=True, level=None, method=None):
+    op = DataFrameMean(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def mean_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameMean(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/median.py

@@ -0,0 +1,56 @@
+# 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 .core import DataFrameReduction, DataFrameReductionMixin
+
+
+class DataFrameMedian(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.MEDIAN
+    _func_name = "median"
+
+    @property
+    def is_atomic(self):
+        return True
+
+
+def median_series(df, axis=None, skipna=True, level=None, method=None):
+    op = DataFrameMedian(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        output_types=[OutputType.series if level is not None else OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def median_dataframe(
+    df,
+    axis=0,
+    skipna=True,
+    level=None,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameMedian(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        numeric_only=numeric_only,
+        output_types=[OutputType.dataframe if level is not None else OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/min.py

@@ -0,0 +1,65 @@
+# 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 .core import DataFrameReduction, DataFrameReductionMixin
+
+
+class DataFrameMin(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.MIN
+    _func_name = "min"
+
+    @property
+    def is_atomic(self):
+        return True
+
+
+def min_series(df, axis=None, skipna=True, level=None, method=None):
+    op = DataFrameMin(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def min_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameMin(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)
+
+
+def min_index(df, axis=None, skipna=True):
+    op = DataFrameMin(
+        axis=axis,
+        skipna=skipna,
+        output_types=[OutputType.scalar],
+    )
+    return op(df)

maxframe/dataframe/reduction/nunique.py

@@ -0,0 +1,142 @@
+# 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.
+
+try:
+    import pyarrow as pa
+except ImportError:  # pragma: no cover
+    pa = None
+
+from ... import opcodes
+from ...config import options
+from ...core import OutputType
+from ...serialization.serializables import BoolField
+from ...utils import lazy_import
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+cudf = lazy_import("cudf")
+
+
+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)
+
+    @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}
+        return ReductionCallable(func_name=func_name, kwargs=kw)
+
+
+def nunique_dataframe(df, axis=0, dropna=True):
+    """
+    Count distinct observations over requested axis.
+
+    Return Series with number of distinct observations. Can ignore NaN
+    values.
+
+    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.
+    dropna : bool, default True
+        Don't include NaN in the counts.
+
+    Returns
+    -------
+    Series
+
+    See Also
+    --------
+    Series.nunique: Method nunique for Series.
+    DataFrame.count: Count non-NA cells for each column or row.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'A': [1, 2, 3], 'B': [1, 1, 1]})
+    >>> df.nunique().execute()
+    A    3
+    B    1
+    dtype: int64
+
+    >>> df.nunique(axis=1).execute()
+    0    1
+    1    2
+    2    2
+    dtype: int64
+    """
+    op = DataFrameNunique(
+        axis=axis,
+        dropna=dropna,
+        output_types=[OutputType.series],
+    )
+    return op(df)
+
+
+def nunique_series(series, dropna=True):
+    """
+    Return number of unique elements in the object.
+
+    Excludes NA values by default.
+
+    Parameters
+    ----------
+    dropna : bool, default True
+        Don't include NaN in the count.
+
+    Returns
+    -------
+    int
+
+    See Also
+    --------
+    DataFrame.nunique: Method nunique for DataFrame.
+    Series.count: Count non-NA/null observations in the Series.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 3, 5, 7, 7])
+    >>> s.execute()
+    0    1
+    1    3
+    2    5
+    3    7
+    4    7
+    dtype: int64
+
+    >>> s.nunique().execute()
+    4
+    """
+    op = DataFrameNunique(
+        dropna=dropna,
+        output_types=[OutputType.scalar],
+        use_arrow_dtype=options.dataframe.use_arrow_dtype,
+    )
+    return op(series)