maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/dataframe/reduction/count.py

@@ -0,0 +1,59 @@
+# Copyright 1999-2024 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 DataFrameReductionMixin, DataFrameReductionOperator
+
+
+class DataFrameCount(DataFrameReductionOperator, DataFrameReductionMixin):
+    _op_type_ = opcodes.COUNT
+    _func_name = "count"
+
+    @property
+    def is_atomic(self):
+        return True
+
+    @classmethod
+    def get_reduction_callable(cls, op):
+        skipna, numeric_only = op.skipna, op.numeric_only
+
+        def count(value):
+            if value.ndim == 1:
+                return value.count()
+            return value.count(skipna=skipna, numeric_only=numeric_only)
+
+        return count
+
+
+def count_series(series, level=None, **kw):
+    method = kw.pop("method", None)
+    op = DataFrameCount(
+        level=level,
+        output_types=[OutputType.scalar],
+        method=method,
+    )
+    return op(series)
+
+
+def count_dataframe(df, axis=0, level=None, numeric_only=False, **kw):
+    method = kw.pop("method", None)
+    op = DataFrameCount(
+        axis=axis,
+        level=level,
+        numeric_only=numeric_only,
+        output_types=[OutputType.series],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/cummax.py

@@ -0,0 +1,30 @@
+# Copyright 1999-2024 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 DataFrameCumReductionMixin, DataFrameCumReductionOperator
+
+
+class DataFrameCummax(DataFrameCumReductionOperator, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMMAX
+    _func_name = "cummax"
+
+
+def cummax(df, axis=None, skipna=True):
+    op = DataFrameCummax(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/cummin.py

@@ -0,0 +1,30 @@
+# Copyright 1999-2024 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 DataFrameCumReductionMixin, DataFrameCumReductionOperator
+
+
+class DataFrameCummin(DataFrameCumReductionOperator, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMMIN
+    _func_name = "cummin"
+
+
+def cummin(df, axis=None, skipna=True):
+    op = DataFrameCummin(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/cumprod.py

@@ -0,0 +1,30 @@
+# Copyright 1999-2024 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 DataFrameCumReductionMixin, DataFrameCumReductionOperator
+
+
+class DataFrameCumprod(DataFrameCumReductionOperator, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMPROD
+    _func_name = "cumprod"
+
+
+def cumprod(df, axis=None, skipna=True):
+    op = DataFrameCumprod(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/cumsum.py

@@ -0,0 +1,30 @@
+# Copyright 1999-2024 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 DataFrameCumReductionMixin, DataFrameCumReductionOperator
+
+
+class DataFrameCumsum(DataFrameCumReductionOperator, DataFrameCumReductionMixin):
+    _op_type_ = opcodes.CUMSUM
+    _func_name = "cumsum"
+
+
+def cumsum(df, axis=None, skipna=True):
+    op = DataFrameCumsum(
+        axis=axis,
+        skipna=skipna,
+        output_types=df.op.output_types,
+    )
+    return op(df)

maxframe/dataframe/reduction/custom_reduction.py

@@ -0,0 +1,42 @@
+# Copyright 1999-2024 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 AnyField
+from .core import DataFrameReductionMixin, DataFrameReductionOperator
+
+
+class DataFrameCustomReduction(DataFrameReductionOperator, DataFrameReductionMixin):
+    _op_type_ = opcodes.CUSTOM_REDUCTION
+    _func_name = "custom_reduction"
+
+    custom_reduction = AnyField("custom_reduction")
+
+    @property
+    def is_atomic(self):
+        return True
+
+    def get_reduction_args(self, axis=None):
+        return dict()
+
+
+def build_custom_reduction_result(df, custom_reduction_obj, method=None):
+    output_type = OutputType.series if df.ndim == 2 else OutputType.scalar
+    op = DataFrameCustomReduction(
+        custom_reduction=custom_reduction_obj,
+        output_types=[output_type],
+        method=method,
+    )
+    return op(df)

maxframe/dataframe/reduction/kurtosis.py

@@ -0,0 +1,104 @@
+# Copyright 1999-2024 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 DataFrameReductionMixin, DataFrameReductionOperator
+
+
+class DataFrameKurtosis(DataFrameReductionOperator, 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):
+        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
+
+
+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-2024 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 DataFrameReductionMixin, DataFrameReductionOperator
+
+
+class DataFrameMax(DataFrameReductionOperator, 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,61 @@
+# Copyright 1999-2024 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 DataFrameReductionMixin, DataFrameReductionOperator
+
+
+class DataFrameMean(DataFrameReductionOperator, 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
+
+
+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/min.py

@@ -0,0 +1,65 @@
+# Copyright 1999-2024 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 DataFrameReductionMixin, DataFrameReductionOperator
+
+
+class DataFrameMin(DataFrameReductionOperator, 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,141 @@
+# Copyright 1999-2024 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 DataFrameReductionMixin, DataFrameReductionOperator
+
+cudf = lazy_import("cudf")
+
+
+class DataFrameNunique(DataFrameReductionOperator, 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
+
+    @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
+
+
+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)