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

maxframe/dataframe/groupby/rolling.py

@@ -0,0 +1,206 @@
+# 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 ...serialization.serializables import AnyField, DictField
+from ..window.rolling import Rolling
+from .core import BaseGroupByWindowOp
+
+_supported_funcs = {"sum", "mean", "std", "var", "median", "min", "max", "count"}
+
+
+class GroupByRollingAgg(BaseGroupByWindowOp):
+    _op_type_ = opcodes.ROLLING_AGG
+
+    func = AnyField("func", default=None)
+    kwargs = DictField("kwargs", default_factory=dict)
+
+    def _calc_mock_result_df(self, mock_groupby):
+        rolling_args = self.window_params.copy()
+        # exclude MF-specific args
+        for key in Rolling._mf_specific_fields:
+            rolling_args.pop(key, None)
+
+        def apply_func(frame, **_):
+            return getattr(frame.rolling(**rolling_args), self.func)()
+
+        return mock_groupby.apply(apply_func, include_groups=False)
+
+
+class RollingGroupby(Rolling):
+    def aggregate(self, func, **kwargs):
+        if func not in _supported_funcs:
+            raise NotImplementedError(f"func {func} is not supported")
+        op = GroupByRollingAgg(
+            func=func,
+            groupby_params=self.input.op.groupby_params,
+            window_params=self.params,
+            kwargs=kwargs,
+        )
+        return op(self.input)
+
+
+def rolling(
+    groupby,
+    window,
+    min_periods=None,
+    *,
+    center=False,
+    win_type=None,
+    on=None,
+    axis=0,
+    closed=None,
+    shift=0,
+    order_cols=None,
+    ascending=True,
+) -> RollingGroupby:
+    """
+    Return a rolling grouper, providing rolling functionality per group.
+
+    Parameters
+    ----------
+    window : int, timedelta, str, offset, or BaseIndexer subclass
+        Size of the moving window.
+
+        If an integer, the fixed number of observations used for
+        each window.
+
+        If a timedelta, str, or offset, the time period of each window. Each
+        window will be a variable sized based on the observations included in
+        the time-period. This is only valid for datetimelike indexes.
+        To learn more about the offsets & frequency strings, please see `this link
+        <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
+
+        If a BaseIndexer subclass, the window boundaries
+        based on the defined ``get_window_bounds`` method. Additional rolling
+        keyword arguments, namely ``min_periods``, ``center``, ``closed`` and
+        ``step`` will be passed to ``get_window_bounds``.
+
+    min_periods : int, default None
+        Minimum number of observations in window required to have a value;
+        otherwise, result is ``np.nan``.
+
+        For a window that is specified by an offset,
+        ``min_periods`` will default to 1.
+
+        For a window that is specified by an integer, ``min_periods`` will default
+        to the size of the window.
+
+    center : bool, default False
+        If False, set the window labels as the right edge of the window index.
+
+        If True, set the window labels as the center of the window index.
+
+    win_type : str, default None
+        If ``None``, all points are evenly weighted.
+
+        If a string, it must be a valid `scipy.signal window function
+        <https://docs.scipy.org/doc/scipy/reference/signal.windows.html#module-scipy.signal.windows>`__.
+
+        Certain Scipy window types require additional parameters to be passed
+        in the aggregation function. The additional parameters must match
+        the keywords specified in the Scipy window type method signature.
+
+    on : str, optional
+        For a DataFrame, a column label or Index level on which
+        to calculate the rolling window, rather than the DataFrame's index.
+
+        Provided integer column is ignored and excluded from result since
+        an integer index is not used to calculate the rolling window.
+
+    axis : int or str, default 0
+        If ``0`` or ``'index'``, roll across the rows.
+
+        If ``1`` or ``'columns'``, roll across the columns.
+
+        For `Series` this parameter is unused and defaults to 0.
+
+    closed : str, default None
+        If ``'right'``, the first point in the window is excluded from calculations.
+
+        If ``'left'``, the last point in the window is excluded from calculations.
+
+        If ``'both'``, no points in the window are excluded from calculations.
+
+        If ``'neither'``, the first and last points in the window are excluded
+        from calculations.
+
+        Default ``None`` (``'right'``).
+
+    shift : int, default 0
+        If specified, the window will be shifted by `shift` rows (or data will be
+        shifted by `-shift` rows) before computing window function.
+
+    Returns
+    -------
+    maxframe.dataframe.groupby.RollingGroupby
+        Return a new grouper with our rolling appended.
+
+    See Also
+    --------
+    Series.rolling : Calling object with Series data.
+    DataFrame.rolling : Calling object with DataFrames.
+    Series.groupby : Apply a function groupby to a Series.
+    DataFrame.groupby : Apply a function groupby.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'A': [1, 1, 2, 2],
+    ...                    'B': [1, 2, 3, 4],
+    ...                    'C': [0.362, 0.227, 1.267, -0.562]})
+    >>> df.execute()
+          A  B      C
+    0     1  1  0.362
+    1     1  2  0.227
+    2     2  3  1.267
+    3     2  4 -0.562
+
+    >>> df.groupby('A').rolling(2).sum().execute()
+        B      C
+    A
+    1 0  NaN    NaN
+      1  3.0  0.589
+    2 2  NaN    NaN
+      3  7.0  0.705
+
+    >>> df.groupby('A').rolling(2, min_periods=1).sum().execute()
+        B      C
+    A
+    1 0  1.0  0.362
+      1  3.0  0.589
+    2 2  3.0  1.267
+      3  7.0  0.705
+
+    >>> df.groupby('A').rolling(2, on='B').sum().execute()
+        B      C
+    A
+    1 0  1    NaN
+      1  2  0.589
+    2 2  3    NaN
+      3  4  0.705
+    """
+    return RollingGroupby(
+        input=groupby,
+        window=window,
+        min_periods=min_periods,
+        center=center,
+        win_type=win_type,
+        on=on,
+        axis=axis,
+        closed=closed,
+        shift=shift,
+        order_cols=order_cols,
+        ascending=ascending,
+    )

maxframe/dataframe/groupby/shift.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 ... import opcodes
+from ...serialization.serializables import AnyField, Int64Field
+from .core import BaseGroupByWindowOp
+
+
+class GroupByShift(BaseGroupByWindowOp):
+    _op_type_ = opcodes.SHIFT
+
+    periods = Int64Field("periods", default=None)
+    freq = AnyField("freq", default=None)
+    fill_value = AnyField("fill_value", default=None)
+
+    def _calc_mock_result_df(self, mock_groupby):
+        return mock_groupby.shift(
+            self.periods, freq=self.freq, fill_value=self.fill_value
+        )
+
+
+def shift(
+    groupby, periods=1, freq=None, fill_value=None, order_cols=None, ascending=True
+):
+    """
+    Shift each group by periods observations.
+
+    If freq is passed, the index will be increased using the periods and the freq.
+
+    Parameters
+    ----------
+    periods : int | Sequence[int], default 1
+        Number of periods to shift. If a list of values, shift each group by
+        each period.
+    freq : str, optional
+        Frequency string.
+
+    fill_value : optional
+        The scalar value to use for newly introduced missing values.
+
+    Returns
+    -------
+    Series or DataFrame
+        Object shifted within each group.
+
+    See Also
+    --------
+    Index.shift : Shift values of Index.
+
+    Examples
+    --------
+
+    For SeriesGroupBy:
+
+    >>> import maxframe.dataframe as md
+    >>> lst = ['a', 'a', 'b', 'b']
+    >>> ser = md.Series([1, 2, 3, 4], index=lst)
+    >>> ser.execute()
+    a    1
+    a    2
+    b    3
+    b    4
+    dtype: int64
+    >>> ser.groupby(level=0).shift(1).execute()
+    a    NaN
+    a    1.0
+    b    NaN
+    b    3.0
+    dtype: float64
+
+    For DataFrameGroupBy:
+
+    >>> data = [[1, 2, 3], [1, 5, 6], [2, 5, 8], [2, 6, 9]]
+    >>> df = md.DataFrame(data, columns=["a", "b", "c"],
+    ...                   index=["tuna", "salmon", "catfish", "goldfish"])
+    >>> df.execute()
+               a  b  c
+        tuna   1  2  3
+      salmon   1  5  6
+     catfish   2  5  8
+    goldfish   2  6  9
+    >>> df.groupby("a").shift(1).execute()
+                  b    c
+        tuna    NaN  NaN
+      salmon    2.0  3.0
+     catfish    NaN  NaN
+    goldfish    5.0  8.0
+    """
+    if not isinstance(ascending, list):
+        ascending = [ascending]
+
+    window_params = dict(
+        order_cols=order_cols,
+        ascending=ascending,
+    )
+    op = GroupByShift(
+        periods=periods,
+        freq=freq,
+        fill_value=fill_value,
+        groupby_params=groupby.op.groupby_params,
+        window_params=window_params,
+    )
+    return op(groupby)

maxframe/dataframe/groupby/tests/test_groupby.py

@@ -284,11 +284,6 @@ def test_groupby_cum():
         assert r.shape == (len(df1), 2)
         assert r.index_value.key == mdf.index_value.key
 
-        r = getattr(mdf.groupby("b"), fun)(axis=1)
-        assert r.op.output_types[0] == OutputType.dataframe
-        assert r.shape == (len(df1), 3)
-        assert r.index_value.key == mdf.index_value.key
-
     r = mdf.groupby("b").cumcount()
     assert r.op.output_types[0] == OutputType.series
     assert r.shape == (len(df1),)

maxframe/dataframe/indexing/__init__.py

@@ -23,23 +23,33 @@ def _install():
     )
     from .align import align
     from .at import at
+    from .droplevel import df_series_droplevel, index_droplevel
+    from .filter import filter_dataframe
+    from .get_level_values import get_level_values
     from .getitem import dataframe_getitem, series_getitem
     from .iat import iat
     from .iloc import head, iloc, index_getitem, index_setitem, tail
-    from .insert import df_insert
+    from .insert import df_insert, index_insert
     from .loc import loc
     from .reindex import reindex, reindex_like
     from .rename import df_rename, index_rename, index_set_names, series_rename
     from .rename_axis import rename_axis
+    from .reorder_levels import df_reorder_levels, series_reorder_levels
     from .reset_index import df_reset_index, series_reset_index
     from .sample import sample
     from .set_axis import df_set_axis, series_set_axis
     from .set_index import set_index
     from .setitem import dataframe_setitem
+    from .swaplevel import df_swaplevel, series_swaplevel
+    from .take import take
+    from .truncate import truncate
     from .where import mask, where
+    from .xs import xs
 
     for cls in DATAFRAME_TYPE + SERIES_TYPE:
         setattr(cls, "at", property(fget=at))
+        setattr(cls, "droplevel", df_series_droplevel)
+        setattr(cls, "filter", filter_dataframe)
         setattr(cls, "head", head)
         setattr(cls, "iat", property(fget=iat))
         setattr(cls, "iloc", property(fget=iloc))
@@ -50,7 +60,10 @@ def _install():
         setattr(cls, "rename_axis", rename_axis)
         setattr(cls, "sample", sample)
         setattr(cls, "tail", tail)
+        setattr(cls, "take", take)
+        setattr(cls, "truncate", truncate)
         setattr(cls, "where", where)
+        setattr(cls, "xs", xs)
 
     for cls in DATAFRAME_TYPE:
         setattr(cls, "add_prefix", df_add_prefix)
@@ -59,10 +72,12 @@ def _install():
         setattr(cls, "__getitem__", dataframe_getitem)
         setattr(cls, "insert", df_insert)
         setattr(cls, "rename", df_rename)
+        setattr(cls, "reorder_levels", df_reorder_levels)
         setattr(cls, "reset_index", df_reset_index)
         setattr(cls, "set_axis", df_set_axis)
         setattr(cls, "set_index", set_index)
         setattr(cls, "__setitem__", dataframe_setitem)
+        setattr(cls, "swaplevel", df_swaplevel)
 
     for cls in SERIES_TYPE:
         setattr(cls, "add_prefix", series_add_prefix)
@@ -70,13 +85,18 @@ def _install():
         setattr(cls, "align", align)
         setattr(cls, "__getitem__", series_getitem)
         setattr(cls, "rename", series_rename)
+        setattr(cls, "reorder_levels", series_reorder_levels)
         setattr(cls, "reset_index", series_reset_index)
         setattr(cls, "set_axis", series_set_axis)
+        setattr(cls, "swaplevel", series_swaplevel)
 
     for cls in INDEX_TYPE:
+        setattr(cls, "droplevel", index_droplevel)
+        setattr(cls, "get_level_values", get_level_values)
         setattr(cls, "__getitem__", index_getitem)
-        setattr(cls, "__setitem__", index_setitem)
+        setattr(cls, "insert", index_insert)
         setattr(cls, "rename", index_rename)
+        setattr(cls, "__setitem__", index_setitem)
         setattr(cls, "set_names", index_set_names)
 
 

maxframe/dataframe/indexing/droplevel.py

@@ -0,0 +1,195 @@
+# 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 ...serialization.serializables import AnyField, Int32Field
+from ..core import INDEX_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_df, build_series, parse_index, validate_axis
+
+
+class DataFrameDropLevel(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DROPLEVEL
+
+    level = AnyField("level")
+    axis = Int32Field("axis", default=0)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def __call__(self, df_obj):
+        if isinstance(df_obj, INDEX_TYPE):
+            # For Index objects
+            empty_index = df_obj.index_value.to_pandas()
+            result_index = empty_index.droplevel(self.level)
+            return self.new_index(
+                [df_obj],
+                shape=(df_obj.shape[0],),
+                dtype=result_index.dtype,
+                index_value=parse_index(result_index, store_data=False),
+                name=result_index.name,
+            )
+        elif df_obj.ndim == 1:
+            # For Series objects
+            empty_series = build_series(df_obj)
+            result_index = empty_series.index.droplevel(self.level)
+
+            return self.new_series(
+                [df_obj],
+                shape=df_obj.shape,
+                dtype=df_obj.dtype,
+                index_value=parse_index(result_index, store_data=False),
+                name=df_obj.name,
+            )
+        else:
+            # For DataFrame objects
+            result_dtypes = df_obj.dtypes
+            result_shape = (df_obj.shape[0], df_obj.shape[1])
+
+            empty_df = build_df(df_obj)
+            if self.axis == 0:
+                # Dropping levels from index
+                result_index = empty_df.index.droplevel(self.level)
+                result_index_value = parse_index(result_index, store_data=False)
+                result_columns_value = df_obj.columns_value
+            else:
+                # Dropping levels from columns
+                result_columns = empty_df.columns.droplevel(self.level)
+                result_columns_value = parse_index(result_columns, store_data=True)
+                result_index_value = df_obj.index_value
+
+            return self.new_dataframe(
+                [df_obj],
+                shape=result_shape,
+                dtypes=result_dtypes,
+                index_value=result_index_value,
+                columns_value=result_columns_value,
+            )
+
+
+def _droplevel(df_obj, level, axis=0):
+    axis = validate_axis(axis, df_obj)
+    op = DataFrameDropLevel(level=level, axis=axis)
+    return op(df_obj)
+
+
+def df_series_droplevel(df_or_series, level, axis=0):
+    """
+    Return Series/DataFrame with requested index / column level(s) removed.
+
+    Parameters
+    ----------
+    level : int, str, or list-like
+        If a string is given, must be the name of a level
+        If list-like, elements must be names or positional indexes
+        of levels.
+
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        Axis along which the level(s) is removed:
+
+        * 0 or 'index': remove level(s) in column.
+        * 1 or 'columns': remove level(s) in row.
+
+        For `Series` this parameter is unused and defaults to 0.
+
+    Returns
+    -------
+    Series/DataFrame
+        Series/DataFrame with requested index / column level(s) removed.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([
+    ...     [1, 2, 3, 4],
+    ...     [5, 6, 7, 8],
+    ...     [9, 10, 11, 12]
+    ... ]).set_index([0, 1]).rename_axis(['a', 'b'])
+
+    >>> df.columns = md.MultiIndex.from_tuples([
+    ...     ('c', 'e'), ('d', 'f')
+    ... ], names=['level_1', 'level_2'])
+
+    >>> df.execute()
+    level_1   c   d
+    level_2   e   f
+    a b
+    1 2      3   4
+    5 6      7   8
+    9 10    11  12
+
+    >>> df.droplevel('a').execute()
+    level_1   c   d
+    level_2   e   f
+    b
+    2        3   4
+    6        7   8
+    10      11  12
+
+    >>> df.droplevel('level_2', axis=1).execute()
+    level_1   c   d
+    a b
+    1 2      3   4
+    5 6      7   8
+    9 10    11  12
+    """
+    return _droplevel(df_or_series, level, axis)
+
+
+def index_droplevel(idx, level):
+    """
+    Return index with requested level(s) removed.
+
+    If resulting index has only 1 level left, the result will be
+    of Index type, not MultiIndex. The original index is not modified inplace.
+
+    Parameters
+    ----------
+    level : int, str, or list-like, default 0
+        If a string is given, must be the name of a level
+        If list-like, elements must be names or indexes of levels.
+
+    Returns
+    -------
+    Index or MultiIndex
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> mi = md.MultiIndex.from_arrays(
+    ... [[1, 2], [3, 4], [5, 6]], names=['x', 'y', 'z'])
+    >>> mi.execute()
+    MultiIndex([(1, 3, 5),
+                (2, 4, 6)],
+                names=['x', 'y', 'z'])
+
+    >>> mi.droplevel().execute()
+    MultiIndex([(3, 5),
+                (4, 6)],
+                names=['y', 'z'])
+
+    >>> mi.droplevel(2).execute()
+    MultiIndex([(1, 3),
+                (2, 4)],
+                names=['x', 'y'])
+
+    >>> mi.droplevel('z').execute()
+    MultiIndex([(1, 3),
+                (2, 4)],
+                names=['x', 'y'])
+
+    >>> mi.droplevel(['x', 'y']).execute()
+    Index([5, 6], dtype='int64', name='z')
+    """
+    return _droplevel(idx, level)