maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/reshape/pivot_table.py

@@ -0,0 +1,275 @@
+# 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 typing import List
+
+import numpy as np
+import pandas as pd
+from pandas.api.types import is_list_like
+
+from ... import opcodes
+from ...core import EntityData, OutputType
+from ...serialization.serializables import AnyField, BoolField, KeyField, StringField
+from ...utils import no_default
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_df, make_column_list, parse_index
+
+
+class DataFramePivotTable(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.PIVOT_TABLE
+
+    values = AnyField("values", default=None)
+    index = AnyField("index", default=None)
+    columns = AnyField("columns", default=None)
+    aggfunc = AnyField("aggfunc", default="mean")
+    fill_value = AnyField("fill_value", default=None)
+    margins = BoolField("margins", default=False)
+    dropna = BoolField("dropna", default=True)
+    margins_name = StringField("margins_name", default=None)
+    sort = BoolField("sort", default=False)
+
+    # generate intermediate agg result to infer value of columns
+    agg_results = KeyField("agg_results", default=None)
+
+    def __init__(self, aggfunc=None, **kw):
+        if aggfunc is None:
+            aggfunc = "mean"
+        super().__init__(aggfunc=aggfunc, **kw)
+        self._output_types = [OutputType.dataframe]
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFramePivotTable", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if op.agg_results is not None:  # pragma: no branch
+            op.agg_results = inputs[-1]
+
+    def __call__(self, df):
+        index_list = make_column_list(self.index, df.dtypes)
+        columns_list = make_column_list(self.columns, df.dtypes)
+        values_list = make_column_list(self.values, df.dtypes)
+
+        if not index_list:
+            index_data = pd.Index([])
+        elif len(index_list) == 1:
+            index_data = pd.Index(
+                [], dtype=df.dtypes[index_list[0]], name=index_list[0]
+            )
+        else:
+            index_data = pd.MultiIndex.from_frame(build_df(df[index_list]))
+        index_value = parse_index(index_data, df)
+
+        if columns_list is None:  # output columns can be determined
+            sel_df = df
+            groupby_obj = sel_df.groupby(index_list)
+            if values_list:
+                groupby_obj = groupby_obj[values_list]
+            aggregated_df = groupby_obj.agg(self.aggfunc)
+            index_value = aggregated_df.index_value
+            columns_value = aggregated_df.columns_value
+            dtypes = aggregated_df.dtypes
+        else:
+            self.agg_results = df[columns_list].drop_duplicates()
+            columns_value = dtypes = None
+
+        inputs = [df]
+        if self.agg_results is not None:
+            inputs.append(self.agg_results)
+        return self.new_dataframe(
+            inputs,
+            shape=(np.nan, np.nan),
+            dtypes=dtypes,
+            columns_value=columns_value,
+            index_value=index_value,
+        )
+
+
+def pivot_table(
+    data,
+    values=None,
+    index=None,
+    columns=None,
+    aggfunc="mean",
+    fill_value=None,
+    margins=False,
+    dropna=True,
+    margins_name="All",
+    sort=True,
+):
+    """
+    Create a spreadsheet-style pivot table as a DataFrame.
+
+    The levels in the pivot table will be stored in MultiIndex objects
+    (hierarchical indexes) on the index and columns of the result DataFrame.
+
+    Parameters
+    ----------
+    values : column to aggregate, optional
+    index : column, Grouper, array, or list of the previous
+        If an array is passed, it must be the same length as the data. The
+        list can contain any of the other types (except list).
+        Keys to group by on the pivot table index.  If an array is passed,
+        it is being used as the same manner as column values.
+    columns : column, Grouper, array, or list of the previous
+        If an array is passed, it must be the same length as the data. The
+        list can contain any of the other types (except list).
+        Keys to group by on the pivot table column.  If an array is passed,
+        it is being used as the same manner as column values.
+    aggfunc : function, list of functions, dict, default numpy.mean
+        If list of functions passed, the resulting pivot table will have
+        hierarchical columns whose top level are the function names
+        (inferred from the function objects themselves)
+        If dict is passed, the key is column to aggregate and value
+        is function or list of functions.
+    fill_value : scalar, default None
+        Value to replace missing values with (in the resulting pivot table,
+        after aggregation).
+    margins : bool, default False
+        Add all row / columns (e.g. for subtotal / grand totals).
+    dropna : bool, default True
+        Do not include columns whose entries are all NaN.
+    margins_name : str, default 'All'
+        Name of the row / column that will contain the totals
+        when margins is True.
+    sort : bool, default True
+        Specifies if the result should be sorted.
+
+    Returns
+    -------
+    DataFrame
+        An Excel style pivot table.
+
+    See Also
+    --------
+    DataFrame.pivot : Pivot without aggregation that can handle
+        non-numeric data.
+    DataFrame.melt: Unpivot a DataFrame from wide to long format,
+        optionally leaving identifiers set.
+    wide_to_long : Wide panel to long format. Less flexible but more
+        user-friendly than melt.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",
+    ...                          "bar", "bar", "bar", "bar"],
+    ...                    "B": ["one", "one", "one", "two", "two",
+    ...                          "one", "one", "two", "two"],
+    ...                    "C": ["small", "large", "large", "small",
+    ...                          "small", "large", "small", "small",
+    ...                          "large"],
+    ...                    "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
+    ...                    "E": [2, 4, 5, 5, 6, 6, 8, 9, 9]})
+    >>> df.execute()
+         A    B      C  D  E
+    0  foo  one  small  1  2
+    1  foo  one  large  2  4
+    2  foo  one  large  2  5
+    3  foo  two  small  3  5
+    4  foo  two  small  3  6
+    5  bar  one  large  4  6
+    6  bar  one  small  5  8
+    7  bar  two  small  6  9
+    8  bar  two  large  7  9
+
+    This first example aggregates values by taking the sum.
+
+    >>> table = md.pivot_table(df, values='D', index=['A', 'B'],
+    ...                        columns=['C'], aggfunc=np.sum)
+    >>> table.execute()
+    C        large  small
+    A   B
+    bar one    4.0    5.0
+        two    7.0    6.0
+    foo one    4.0    1.0
+        two    NaN    6.0
+
+    We can also fill missing values using the `fill_value` parameter.
+
+    >>> table = md.pivot_table(df, values='D', index=['A', 'B'],
+    ...                        columns=['C'], aggfunc=np.sum, fill_value=0)
+    >>> table.execute()
+    C        large  small
+    A   B
+    bar one      4      5
+        two      7      6
+    foo one      4      1
+        two      0      6
+
+    The next example aggregates by taking the mean across multiple columns.
+
+    >>> table = md.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
+    ...                        aggfunc={'D': np.mean,
+    ...                                 'E': np.mean})
+    >>> table.execute()
+                    D         E
+    A   C
+    bar large  5.500000  7.500000
+        small  5.500000  8.500000
+    foo large  2.000000  4.500000
+        small  2.333333  4.333333
+
+    We can also calculate multiple types of aggregations for any given
+    value column.
+
+    >>> table = md.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
+    ...                        aggfunc={'D': np.mean,
+    ...                                 'E': [min, max, np.mean]})
+    >>> table.execute()
+                    D    E
+                mean  max      mean  min
+    A   C
+    bar large  5.500000  9.0  7.500000  6.0
+        small  5.500000  9.0  8.500000  8.0
+    foo large  2.000000  5.0  4.500000  4.0
+        small  2.333333  6.0  4.333333  2.0
+    """
+    if index is None and columns is None:
+        raise ValueError(
+            "No group keys passed, need to specify at least one of index or columns"
+        )
+
+    values_list = make_column_list(values, data.dtypes)
+    index_list = make_column_list(index, data.dtypes)
+    columns_list = make_column_list(columns, data.dtypes)
+
+    name_to_attr = {"values": values_list, "index": index_list, "columns": columns_list}
+    for key, val in name_to_attr.items():
+        if val is None:
+            continue
+        if not is_list_like(val):
+            raise ValueError(f"Need to specify {key} as a list-like object.")
+        non_exist_key = next((c for c in val if c not in data.dtypes.index), no_default)
+        if non_exist_key is not no_default:
+            raise ValueError(
+                f"Column {non_exist_key} specified in {key} is not a valid column."
+            )
+
+    if columns is None and not margins:
+        if values_list:
+            data = data[index_list + values_list]
+        return data.groupby(index, sort=sort).agg(aggfunc)
+
+    op = DataFramePivotTable(
+        values=values,
+        index=index,
+        columns=columns,
+        aggfunc=aggfunc,
+        fill_value=fill_value,
+        margins=margins,
+        dropna=dropna,
+        margins_name=margins_name,
+        sort=sort,
+    )
+    return op(data)

maxframe/dataframe/reshape/stack.py

@@ -0,0 +1,240 @@
+# 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 typing import List, Union
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import AnyField, BoolField, KeyField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_df, parse_index
+
+
+class DataFrameStack(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.STACK
+
+    input_df = KeyField("input_df", default=None)
+    level = AnyField("level", default=None)
+    dropna = BoolField("dropna", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameStack", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input_df = op._inputs[0]
+
+    @classmethod
+    def _calc_size(cls, size: int, level: Union[List, int], dtypes: pd.Series):
+        index = dtypes.index
+
+        if not isinstance(index, pd.MultiIndex):
+            return size * len(index)
+
+        if isinstance(level, int):
+            level = [level]
+        return size * np.prod([index.levshape[lev] for lev in level]).item()
+
+    def __call__(self, input_df):
+        test_df = build_df(input_df)
+        test_df = test_df.stack(level=self.level, dropna=self.dropna)
+        if self.dropna:
+            size = np.nan
+        else:
+            size = self._calc_size(input_df.shape[0], self.level, input_df.dtypes)
+        if test_df.ndim == 1:
+            shape = (size,)
+            return self.new_series(
+                [input_df],
+                shape=shape,
+                dtype=test_df.dtype,
+                index_value=parse_index(test_df.index, input_df),
+                name=test_df.name,
+            )
+        else:
+            shape = (size, test_df.shape[1])
+            return self.new_dataframe(
+                [input_df],
+                shape=shape,
+                dtypes=test_df.dtypes,
+                index_value=parse_index(test_df.index, input_df),
+                columns_value=parse_index(test_df.columns, store_data=True),
+            )
+
+
+def stack(df, level=-1, dropna=True):
+    """
+    Stack the prescribed level(s) from columns to index.
+
+    Return a reshaped DataFrame or Series having a multi-level
+    index with one or more new inner-most levels compared to the current
+    DataFrame. The new inner-most levels are created by pivoting the
+    columns of the current dataframe:
+
+      - if the columns have a single level, the output is a Series;
+      - if the columns have multiple levels, the new index
+        level(s) is (are) taken from the prescribed level(s) and
+        the output is a DataFrame.
+
+    Parameters
+    ----------
+    level : int, str, list, default -1
+        Level(s) to stack from the column axis onto the index
+        axis, defined as one index or label, or a list of indices
+        or labels.
+    dropna : bool, default True
+        Whether to drop rows in the resulting Frame/Series with
+        missing values. Stacking a column level onto the index
+        axis can create combinations of index and column values
+        that are missing from the original dataframe. See Examples
+        section.
+
+    Returns
+    -------
+    DataFrame or Series
+        Stacked dataframe or series.
+
+    See Also
+    --------
+    DataFrame.unstack : Unstack prescribed level(s) from index axis
+         onto column axis.
+    DataFrame.pivot : Reshape dataframe from long format to wide
+         format.
+    DataFrame.pivot_table : Create a spreadsheet-style pivot table
+         as a DataFrame.
+
+    Notes
+    -----
+    The function is named by analogy with a collection of books
+    being reorganized from being side by side on a horizontal
+    position (the columns of the dataframe) to being stacked
+    vertically on top of each other (in the index of the
+    dataframe).
+
+    Examples
+    --------
+    **Single level columns**
+
+    >>> import maxframe.dataframe as md
+    >>> df_single_level_cols = md.DataFrame([[0, 1], [2, 3]],
+    ...                                     index=['cat', 'dog'],
+    ...                                     columns=['weight', 'height'])
+
+    Stacking a dataframe with a single level column axis returns a Series:
+
+    >>> df_single_level_cols.execute()
+         weight height
+    cat       0      1
+    dog       2      3
+    >>> df_single_level_cols.stack().execute()
+    cat  weight    0
+         height    1
+    dog  weight    2
+         height    3
+    dtype: int64
+
+    **Multi level columns: simple case**
+
+    >>> multicol1 = pd.MultiIndex.from_tuples([('weight', 'kg'),
+    ...                                        ('weight', 'pounds')])
+    >>> df_multi_level_cols1 = md.DataFrame([[1, 2], [2, 4]],
+    ...                                     index=['cat', 'dog'],
+    ...                                     columns=multicol1)
+
+    Stacking a dataframe with a multi-level column axis:
+
+    >>> df_multi_level_cols1.execute()
+         weight
+             kg    pounds
+    cat       1        2
+    dog       2        4
+    >>> df_multi_level_cols1.stack().execute()
+                weight
+    cat kg           1
+        pounds       2
+    dog kg           2
+        pounds       4
+
+    **Missing values**
+
+    >>> multicol2 = pd.MultiIndex.from_tuples([('weight', 'kg'),
+    ...                                        ('height', 'm')])
+    >>> df_multi_level_cols2 = md.DataFrame([[1.0, 2.0], [3.0, 4.0]],
+    ...                                     index=['cat', 'dog'],
+    ...                                     columns=multicol2)
+
+    It is common to have missing values when stacking a dataframe
+    with multi-level columns, as the stacked dataframe typically
+    has more values than the original dataframe. Missing values
+    are filled with NaNs:
+
+    >>> df_multi_level_cols2.execute()
+        weight height
+            kg      m
+    cat    1.0    2.0
+    dog    3.0    4.0
+    >>> df_multi_level_cols2.stack().execute()
+            height  weight
+    cat kg     NaN     1.0
+        m      2.0     NaN
+    dog kg     NaN     3.0
+        m      4.0     NaN
+
+    **Prescribing the level(s) to be stacked**
+
+    The first parameter controls which level or levels are stacked:
+
+    >>> df_multi_level_cols2.stack(0).execute()
+                 kg    m
+    cat height  NaN  2.0
+        weight  1.0  NaN
+    dog height  NaN  4.0
+        weight  3.0  NaN
+    >>> df_multi_level_cols2.stack([0, 1]).execute()
+    cat  height  m     2.0
+         weight  kg    1.0
+    dog  height  m     4.0
+         weight  kg    3.0
+    dtype: float64
+
+    **Dropping missing values**
+
+    >>> df_multi_level_cols3 = md.DataFrame([[None, 1.0], [2.0, 3.0]],
+    ...                                     index=['cat', 'dog'],
+    ...                                     columns=multicol2)
+
+    Note that rows where all values are missing are dropped by
+    default but this behaviour can be controlled via the dropna
+    keyword parameter:
+
+    >>> df_multi_level_cols3.execute()
+        weight height
+            kg      m
+    cat    NaN    1.0
+    dog    2.0    3.0
+    >>> df_multi_level_cols3.stack(dropna=False).execute()
+            height  weight
+    cat kg     NaN     NaN
+        m      1.0     NaN
+    dog kg     NaN     2.0
+        m      3.0     NaN
+    >>> df_multi_level_cols3.stack(dropna=True).execute()
+            height  weight
+    cat m      1.0     NaN
+    dog kg     NaN     2.0
+        m      3.0     NaN
+    """
+    op = DataFrameStack(input_df=df, level=level, dropna=dropna)
+    return op(df)

maxframe/dataframe/reshape/unstack.py

@@ -0,0 +1,114 @@
+# 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 ...udf import builtin_function
+from ..core import SERIES_TYPE
+
+
+@builtin_function
+def _adjust_names(pivoted, idx_names=None, col_names=None, remove_col_level=False):
+    if remove_col_level:
+        pivoted = pivoted.droplevel(0, axis=1)
+    if idx_names:
+        pivoted = pivoted.rename_axis(idx_names, axis=0)
+    if col_names:
+        pivoted = pivoted.rename_axis(col_names, axis=1)
+    return pivoted
+
+
+def unstack(df_or_series, level=-1, fill_value=None):
+    """
+    Unstack, also known as pivot, Series with MultiIndex to produce DataFrame.
+
+    Parameters
+    ----------
+    level : int, str, or list of these, default last level
+        Level(s) to unstack, can pass level name.
+    fill_value : scalar value, default None
+        Value to use when replacing NaN values.
+
+    Returns
+    -------
+    DataFrame
+        Unstacked Series.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3, 4],
+    ...               index=md.MultiIndex.from_product([['one', 'two'],
+    ...                                                 ['a', 'b']]))
+    >>> s.execute()
+    one  a    1
+         b    2
+    two  a    3
+         b    4
+    dtype: int64
+
+    >>> s.unstack(level=-1).execute()
+         a  b
+    one  1  2
+    two  3  4
+
+    >>> s.unstack(level=0).execute()
+         one  two
+    a    1    3
+    b    2    4
+    """
+    if df_or_series.index.nlevels == 1:
+        if isinstance(df_or_series, SERIES_TYPE):
+            raise ValueError("index must be a MultiIndex to unstack")
+        raw_idx_nlevels = df_or_series.index.nlevels
+        stacked = df_or_series.stack(level=level, fill_value=fill_value)
+        orig_order = list(stacked.index.nlevels)
+        new_order = orig_order[raw_idx_nlevels:] + orig_order[:raw_idx_nlevels]
+        return stacked.reorder_levels(new_order)
+
+    nlevels = df_or_series.index.nlevels
+    idx_names = list(df_or_series.index.names)
+    if df_or_series.ndim == 1:
+        col_names = []
+    else:
+        col_names = list(df_or_series.columns.names)
+
+    name_to_idx = {name: i for i, name in enumerate(idx_names)}
+    level = level if isinstance(level, list) else [level]
+    level_idxes = [(nlevels + name_to_idx.get(lv, lv)) % nlevels for lv in level]
+    level_idx_set = set(level_idxes)
+    level_cols = [f"__level_{idx}" for idx in range(nlevels)]
+
+    if df_or_series.ndim == 1:
+        data = df_or_series.to_frame(name="__data")
+    else:
+        data = df_or_series
+    pivot_val_col = list(data.dtypes.index)
+    pivot_col_col = [level_cols[i] for i in level_idxes]
+    pivot_idx_col = [level_cols[i] for i in range(nlevels) if i not in level_idx_set]
+
+    new_idx_names = [idx_names[i] for i in range(nlevels) if i not in level_idx_set]
+    new_col_names = col_names + [idx_names[i] for i in level_idxes]
+
+    data = data.reset_index(names=level_cols)
+    pivoted = data.pivot(
+        index=pivot_idx_col, columns=pivot_col_col, values=pivot_val_col
+    )
+    pivoted.op.fill_value = fill_value
+    return pivoted.mf.apply_chunk(
+        _adjust_names,
+        col_names=new_col_names,
+        idx_names=new_idx_names,
+        remove_col_level=df_or_series.ndim == 1,
+        skip_infer=True,
+        output_type="dataframe",
+    )

maxframe/dataframe/sort/__init__.py

@@ -0,0 +1,49 @@
+# 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 .rank import DataFrameRank
+from .sort_index import DataFrameSortIndex
+from .sort_values import DataFrameSortValues
+
+
+def _install():
+    from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
+    from .argsort import index_argsort, series_argsort
+    from .nlargest import df_nlargest, series_nlargest
+    from .nsmallest import df_nsmallest, series_nsmallest
+    from .rank import rank
+    from .sort_index import sort_index
+    from .sort_values import dataframe_sort_values, series_sort_values
+
+    for cls in DATAFRAME_TYPE:
+        setattr(cls, "nlargest", df_nlargest)
+        setattr(cls, "nsmallest", df_nsmallest)
+        setattr(cls, "rank", rank)
+        setattr(cls, "sort_values", dataframe_sort_values)
+        setattr(cls, "sort_index", sort_index)
+
+    for cls in SERIES_TYPE:
+        setattr(cls, "argsort", series_argsort)
+        setattr(cls, "nlargest", series_nlargest)
+        setattr(cls, "nsmallest", series_nsmallest)
+        setattr(cls, "rank", rank)
+        setattr(cls, "sort_values", series_sort_values)
+        setattr(cls, "sort_index", sort_index)
+
+    for cls in INDEX_TYPE:
+        setattr(cls, "argsort", index_argsort)
+
+
+_install()
+del _install