maxframe 2.3.0__cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

maxframe/dataframe/reduction/nunique.py

@@ -0,0 +1,149 @@
+# 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, StringField
+from ...utils import lazy_import
+from ..utils import validate_dtype_backend
+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)
+    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}
+        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],
+        dtype_backend=options.dataframe.dtype_backend,
+    )
+    return op(series)

maxframe/dataframe/reduction/prod.py

@@ -0,0 +1,81 @@
+# 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 OutputType
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+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"
+
+    @property
+    def is_atomic(self):
+        return self.min_count == 0
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        skipna, min_count = op.skipna, op.min_count
+        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):
+    op = DataFrameProd(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        min_count=min_count,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def prod_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    min_count=0,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameProd(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        min_count=min_count,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/reduction_size.py

@@ -0,0 +1,36 @@
+# 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 DataFrameSize(DataFrameReduction, DataFrameReductionMixin):
+    _op_type_ = opcodes.REDUCTION_SIZE
+    _func_name = "size"
+
+    @property
+    def is_atomic(self):
+        return True
+
+
+def size_series(df):
+    op = DataFrameSize(output_types=[OutputType.scalar])
+    return op(df)
+
+
+def size_dataframe(df):
+    op = DataFrameSize(output_types=[OutputType.series])
+    return op(df)

maxframe/dataframe/reduction/sem.py

@@ -0,0 +1,73 @@
+# 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 ...serialization.serializables import Int32Field
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+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"
+
+    ddof = Int32Field("ddof", default=None)
+
+    @classmethod
+    def get_reduction_callable(cls, op: "DataFrameSem"):
+        skipna, ddof = op.skipna, op.ddof
+        return SemReductionCallable(
+            func_name="sem", kwargs={"skipna": skipna, "ddof": ddof}
+        )
+
+
+def sem_series(series, axis=None, skipna=True, level=None, ddof=1, method=None):
+    op = DataFrameSem(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        ddof=ddof,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(series)
+
+
+def sem_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    ddof=1,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameSem(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        ddof=ddof,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/skew.py

@@ -0,0 +1,93 @@
+# 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 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"
+
+    bias = BoolField("bias", default=None)
+
+    @classmethod
+    def get_reduction_callable(cls, op: "DataFrameSkew"):
+        skipna, bias = op.skipna, op.bias
+        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):
+    op = DataFrameSkew(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        bias=bias,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def skew_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    numeric_only=None,
+    bias=False,
+    method=None,
+):
+    op = DataFrameSkew(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        numeric_only=numeric_only,
+        bias=bias,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/std.py

@@ -0,0 +1,53 @@
+# 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 ...tensor.arithmetic import sqrt
+from .var import var_dataframe, var_series
+
+
+def std_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    ddof=1,
+    numeric_only=None,
+    method=None,
+):
+    ret = sqrt(
+        var_dataframe(
+            df,
+            axis=axis,
+            skipna=skipna,
+            level=level,
+            ddof=ddof,
+            numeric_only=numeric_only,
+            method=method,
+        )
+    )
+    return ret
+
+
+def std_series(series, axis=None, skipna=True, level=None, ddof=1, method=None):
+    ret = sqrt(
+        var_series(
+            series,
+            axis=axis,
+            skipna=skipna,
+            level=level,
+            ddof=ddof,
+            method=method,
+        )
+    )
+    return ret

maxframe/dataframe/reduction/str_concat.py

@@ -0,0 +1,51 @@
+# 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 ...serialization.serializables import StringField
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+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"
+
+    sep = StringField("sep", default=None)
+    na_rep = StringField("na_rep", default=None)
+
+    def get_reduction_args(self, axis=None):
+        return dict(sep=self.sep, na_rep=self.na_rep)
+
+    @property
+    def is_atomic(self):
+        return True
+
+    @classmethod
+    def get_reduction_callable(cls, op: "DataFrameStrConcat"):
+        sep, na_rep = op.sep, op.na_rep
+        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):
+    output_type = OutputType.series if df.ndim == 2 else OutputType.scalar
+    op = DataFrameStrConcat(sep=sep, na_rep=na_rep, output_types=[output_type])
+    return op(df)

maxframe/dataframe/reduction/sum.py

@@ -0,0 +1,81 @@
+# 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 OutputType
+from .core import DataFrameReduction, DataFrameReductionMixin, ReductionCallable
+
+
+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"
+
+    @property
+    def is_atomic(self):
+        return self.min_count == 0
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        skipna, min_count = op.skipna, op.min_count
+        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):
+    op = DataFrameSum(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        min_count=min_count,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(df)
+
+
+def sum_dataframe(
+    df,
+    axis=None,
+    skipna=True,
+    level=None,
+    min_count=0,
+    numeric_only=None,
+    method=None,
+):
+    op = DataFrameSum(
+        axis=axis,
+        skipna=skipna,
+        level=level,
+        min_count=min_count,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/tests/__init__.py

@@ -0,0 +1,13 @@
+# 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.