maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.2.0__cp37-cp37m-win32.whl

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,6 +23,9 @@ 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
@@ -31,15 +34,22 @@ def _install():
     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,17 @@ 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, "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)

maxframe/dataframe/indexing/filter.py

@@ -0,0 +1,169 @@
+# 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 re
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import get_output_types
+from ...serialization.serializables import Int32Field, ListField, StringField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+
+class DataFrameFilter(DataFrameOperatorMixin, DataFrameOperator):
+    _op_type_ = opcodes.DATAFRAME_FILTER
+
+    items = ListField("items", default=None)
+    like = StringField("like", default=None)
+    regex = StringField("regex", default=None)
+    axis = Int32Field("axis", default=None)
+
+    def __call__(self, df_or_series):
+        self._output_types = get_output_types(df_or_series)
+
+        # Get axis labels to filter
+        if self.axis == 0:
+            # Filter by index
+            labels = df_or_series.index_value.to_pandas()
+        else:
+            # Filter by columns (DataFrame only)
+            if not hasattr(df_or_series, "columns"):
+                raise ValueError("axis=1 (columns) not valid for Series")
+            labels = df_or_series.columns_value.to_pandas()
+
+        # Apply filter criteria
+        filtered_labels = self._apply_filter_criteria(labels)
+
+        # Calculate output shape and metadata
+        out_params = self._calculate_output_metadata(df_or_series, filtered_labels)
+        return self.new_tileable([df_or_series], **out_params)
+
+    def _apply_filter_criteria(self, labels):
+        """Apply filter criteria to labels"""
+        if self.items is not None:
+            # Exact match filter
+            return [label for label in labels if label in self.items]
+        elif self.like is not None:
+            # Substring match filter
+            return [label for label in labels if self.like in str(label)]
+        elif self.regex is not None:
+            # Regex match filter
+            pattern = re.compile(self.regex)
+            return [label for label in labels if pattern.search(str(label))]
+        else:
+            return list(labels)
+
+    def _calculate_output_metadata(self, input_tileable, filtered_labels):
+        input_shape = input_tileable.shape
+
+        out_params = input_tileable.params
+        if self.axis == 0:
+            out_params["shape"] = (len(filtered_labels) or np.nan,) + input_shape[1:]
+            out_params["index_value"] = parse_index(
+                pd.Index(filtered_labels), input_tileable.index_value
+            )
+        else:
+            out_params["shape"] = (input_shape[0], len(filtered_labels))
+            out_params["columns_value"] = parse_index(
+                input_tileable.dtypes[filtered_labels].index, store_data=True
+            )
+        return out_params
+
+
+def filter_dataframe(df_or_series, items=None, like=None, regex=None, axis=None):
+    """
+    Subset the dataframe rows or columns according to the specified index labels.
+
+    Note that this routine does not filter a dataframe on its
+    contents. The filter is applied to the labels of the index.
+
+    Parameters
+    ----------
+    items : list-like
+        Keep labels from axis which are in items.
+    like : str
+        Keep labels from axis for which "like in label == True".
+    regex : str (regular expression)
+        Keep labels from axis for which re.search(regex, label) == True.
+    axis : {0 or 'index', 1 or 'columns', None}, default None
+        The axis to filter on, expressed either as an index (int)
+        or axis name (str). By default this is the info axis, 'columns' for
+        DataFrame. For `Series` this parameter is unused and defaults to `None`.
+
+    Returns
+    -------
+    same type as input object
+
+    See Also
+    --------
+    DataFrame.loc : Access a group of rows and columns
+        by label(s) or a boolean array.
+
+    Notes
+    -----
+    The ``items``, ``like``, and ``regex`` parameters are
+    enforced to be mutually exclusive.
+
+    ``axis`` defaults to the info axis that is used when indexing
+    with ``[]``.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame(mt.array(([1, 2, 3], [4, 5, 6])),
+    ...                   index=['mouse', 'rabbit'],
+    ...                   columns=['one', 'two', 'three'])
+    >>> df.execute()
+            one  two  three
+    mouse     1    2      3
+    rabbit    4    5      6
+
+    >>> # select columns by name
+    >>> df.filter(items=['one', 'three']).execute()
+             one  three
+    mouse     1      3
+    rabbit    4      6
+
+    >>> # select columns by regular expression
+    >>> df.filter(regex='e$', axis=1).execute()
+             one  three
+    mouse     1      3
+    rabbit    4      6
+
+    >>> # select rows containing 'bbi'
+    >>> df.filter(like='bbi', axis=0).execute()
+             one  two  three
+    rabbit    4    5      6
+    """
+    if axis is None:
+        # For Series, axis is always 0 (index)
+        # For DataFrame, default is 1 (columns)
+        if hasattr(df_or_series, "columns"):
+            axis = 1  # DataFrame - filter columns by default
+        else:
+            axis = 0  # Series - filter index
+
+    param_count = sum(x is not None for x in [items, like, regex])
+    if param_count == 0:
+        raise TypeError("Must pass either `items`, `like`, or `regex`")
+    if param_count > 1:
+        raise TypeError(
+            "keyword arguments `items`, `like`, `regex` are mutually exclusive"
+        )
+    op = DataFrameFilter(items=items, like=like, regex=regex, axis=axis)
+    return op(df_or_series)

maxframe/dataframe/indexing/get_level_values.py

@@ -0,0 +1,76 @@
+# 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
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+
+class IndexGetLevelValues(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.GET_LEVEL_VALUES
+
+    level = AnyField("level")
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def __call__(self, index):
+        empty_index = index.index_value.to_pandas()
+        result_index = empty_index.get_level_values(self.level)
+
+        return self.new_index(
+            [index],
+            shape=(index.shape[0],),
+            dtype=result_index.dtype,
+            index_value=parse_index(result_index, store_data=False),
+            names=result_index.names,
+        )
+
+
+def get_level_values(index, level):
+    """
+    Return vector of label values for requested level.
+
+    Length of returned vector is equal to the length of the index.
+
+    Parameters
+    ----------
+    level : int or str
+        ``level`` is either the integer position of the level in the
+        MultiIndex, or the name of the level.
+
+    Returns
+    -------
+    values : Index
+        Values is a level of this MultiIndex converted to
+        a single :class:`Index` (or subclass thereof).
+
+    Examples
+    --------
+    Create a MultiIndex:
+
+    >>> import maxframe.dataframe as md
+    >>> import pandas as pd
+    >>> mi = md.Index(pd.MultiIndex.from_arrays((list('abc'), list('def')), names=['level_1', 'level_2']))
+
+    Get level values by supplying level as either integer or name:
+
+    >>> mi.get_level_values(0).execute()
+    Index(['a', 'b', 'c'], dtype='object', name='level_1')
+    >>> mi.get_level_values('level_2').execute()
+    Index(['d', 'e', 'f'], dtype='object', name='level_2')
+    """
+    op = IndexGetLevelValues(level=level)
+    return op(index)

maxframe/dataframe/indexing/iat.py

@@ -34,4 +34,49 @@ class DataFrameIat:
 
 
 def iat(a):
+    """
+    Access a single value for a row/column pair by integer position.
+
+    Similar to ``iloc``, in that both provide integer-based lookups. Use
+    ``iat`` if you only need to get or set a single value in a DataFrame
+    or Series.
+
+    Raises
+    ------
+    IndexError
+        When integer position is out of bounds.
+
+    See Also
+    --------
+    DataFrame.at : Access a single value for a row/column label pair.
+    DataFrame.loc : Access a group of rows and columns by label(s).
+    DataFrame.iloc : Access a group of rows and columns by integer position(s).
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
+    ...                   columns=['A', 'B', 'C'])
+    >>> df.execute()
+        A   B   C
+    0   0   2   3
+    1   0   4   1
+    2  10  20  30
+
+    Get value at specified row/column pair
+
+    >>> df.iat[1, 2].execute()
+    1
+
+    Set value at specified row/column pair
+
+    >>> df.iat[1, 2] = 10
+    >>> df.iat[1, 2].execute()
+    10
+
+    Get value within a series
+
+    >>> df.loc[0].iat[1].execute()
+    2
+    """
     return DataFrameIat(a)