maxframe 2.0.0b2__cp38-cp38-win_amd64.whl → 2.2.0__cp38-cp38-win_amd64.whl

maxframe/dataframe/indexing/reorder_levels.py

@@ -0,0 +1,143 @@
+# 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 pandas as pd
+
+from ... import opcodes
+from ...core import get_output_types
+from ...serialization.serializables import AnyField, Int32Field
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+
+class DataFrameReorderLevels(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.REORDER_LEVELS
+
+    order = AnyField("order")
+    axis = Int32Field("axis", default=0)
+
+    def __call__(self, df_or_series):
+        # Determine output type
+        self._output_types = get_output_types(df_or_series)
+
+        if self.axis == 0:
+            src_idx_value = df_or_series.index_value
+        else:
+            src_idx_value = df_or_series.columns_value
+
+        # Create reordered index
+        pd_index = src_idx_value.to_pandas()
+        if not isinstance(pd_index, pd.MultiIndex):
+            raise ValueError("reorder_levels can only be used with MultiIndex")
+        pd_index = pd_index.reorder_levels(self.order)
+
+        params = df_or_series.params
+        if self.axis == 0:
+            params["index_value"] = parse_index(pd_index)
+        else:
+            params["columns_value"] = parse_index(pd_index, store_data=True)
+        return self.new_tileable([df_or_series], **params)
+
+
+def _reorder_levels(df_or_series, order, axis=0):
+    axis = validate_axis(axis, df_or_series)
+    op = DataFrameReorderLevels(order=order, axis=axis)
+    return op(df_or_series)
+
+
+def df_reorder_levels(df, order, axis=0):
+    """
+    Rearrange index levels using input order. May not drop or duplicate levels.
+
+    Parameters
+    ----------
+    order : list of int or list of str
+        List representing new level order. Reference level by number
+        (position) or by key (label).
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        Where to reorder levels.
+
+    Returns
+    -------
+    DataFrame
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> data = {
+    ...     "class": ["Mammals", "Mammals", "Reptiles"],
+    ...     "diet": ["Omnivore", "Carnivore", "Carnivore"],
+    ...     "species": ["Humans", "Dogs", "Snakes"],
+    ... }
+    >>> df = md.DataFrame(data, columns=["class", "diet", "species"])
+    >>> df = df.set_index(["class", "diet"])
+    >>> df.execute()
+                                      species
+    class      diet
+    Mammals    Omnivore                Humans
+               Carnivore                 Dogs
+    Reptiles   Carnivore               Snakes
+
+    Let's reorder the levels of the index:
+
+    >>> df.reorder_levels(["diet", "class"]).execute()
+                                      species
+    diet      class
+    Omnivore  Mammals                  Humans
+    Carnivore Mammals                    Dogs
+              Reptiles                 Snakes
+    """
+    return _reorder_levels(df, order, axis=axis)
+
+
+def series_reorder_levels(series, order):
+    """
+    Rearrange index levels using input order.
+
+    May not drop or duplicate levels.
+
+    Parameters
+    ----------
+    order : list of int representing new level order
+        Reference level by number or key.
+
+    Returns
+    -------
+    type of caller (new object)
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> arrays = [mt.array(["dog", "dog", "cat", "cat", "bird", "bird"]),
+    ...           mt.array(["white", "black", "white", "black", "white", "black"])]
+    >>> s = md.Series([1, 2, 3, 3, 5, 2], index=arrays)
+    >>> s.execute()
+    dog   white    1
+          black    2
+    cat   white    3
+          black    3
+    bird  white    5
+          black    2
+    dtype: int64
+    >>> s.reorder_levels([1, 0]).execute()
+    white  dog     1
+    black  dog     2
+    white  cat     3
+    black  cat     3
+    white  bird    5
+    black  bird    2
+    dtype: int64
+    """
+    return _reorder_levels(series, order)

maxframe/dataframe/indexing/reset_index.py

@@ -18,10 +18,12 @@ import pandas as pd
 from ... import opcodes
 from ...core import OutputType
 from ...serialization.serializables import AnyField, BoolField
-from ...utils import no_default
+from ...utils import no_default, pd_release_version
 from ..operators import DATAFRAME_TYPE, DataFrameOperator, DataFrameOperatorMixin
 from ..utils import build_empty_df, build_empty_series, parse_index
 
+_reset_index_has_names = pd_release_version >= (1, 5)
+
 
 class DataFrameResetIndex(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.RESET_INDEX
@@ -29,8 +31,10 @@ class DataFrameResetIndex(DataFrameOperator, DataFrameOperatorMixin):
     level = AnyField("level", default=None)
     drop = BoolField("drop", default=False)
     name = AnyField("name", default=None)
-    col_level = AnyField("col_level", default=0)
-    col_fill = AnyField("col_fill", default="")
+    col_level = AnyField("col_level", default=None)
+    col_fill = AnyField("col_fill", default=None)
+    incremental_index = BoolField("incremental_index", default=False)
+    names = AnyField("names", default=None)
 
     def __init__(self, output_types=None, **kwargs):
         super().__init__(_output_types=output_types, **kwargs)
@@ -76,9 +80,26 @@ class DataFrameResetIndex(DataFrameOperator, DataFrameOperatorMixin):
         else:
             empty_df = build_empty_df(a.dtypes)
             empty_df.index = a.index_value.to_pandas()[:0]
-            empty_df = empty_df.reset_index(
-                level=self.level, col_level=self.col_level, col_fill=self.col_fill
-            )
+
+            if self.names and _reset_index_has_names:
+                empty_df = empty_df.reset_index(
+                    level=self.level,
+                    col_level=self.col_level,
+                    col_fill=self.col_fill,
+                    names=self.names,
+                )
+            else:
+                empty_df = empty_df.reset_index(
+                    level=self.level, col_level=self.col_level, col_fill=self.col_fill
+                )
+                if self.names:
+                    names = (
+                        [self.names] if not isinstance(self.names, list) else self.names
+                    )
+                    cols = list(empty_df.columns)
+                    cols[: len(names)] = names
+                    empty_df.columns = pd.Index(cols, name=empty_df.columns.name)
+
             shape = (a.shape[0], len(empty_df.columns))
             columns_value = parse_index(empty_df.columns, store_data=True)
             dtypes = empty_df.dtypes
@@ -105,6 +126,8 @@ def df_reset_index(
     inplace=False,
     col_level=0,
     col_fill="",
+    names=None,
+    incremental_index=False,
 ):
     """
     Reset the index, or a level of it.
@@ -255,6 +278,8 @@ def df_reset_index(
         drop=drop,
         col_level=col_level,
         col_fill=col_fill,
+        names=names,
+        incremental_index=incremental_index,
         output_types=[OutputType.dataframe],
     )
     ret = op(df)
@@ -270,6 +295,7 @@ def series_reset_index(
     drop=False,
     name=no_default,
     inplace=False,
+    incremental_index=False,
 ):
     """
     Generate a new DataFrame or Series with the index reset.
@@ -389,6 +415,7 @@ def series_reset_index(
         level=level,
         drop=drop,
         name=name,
+        incremental_index=incremental_index,
         output_types=[OutputType.series if drop else OutputType.dataframe],
     )
     ret = op(series)

maxframe/dataframe/indexing/sample.py

@@ -25,6 +25,7 @@ from ...serialization.serializables import (
     Float64Field,
     Int8Field,
     Int64Field,
+    KeyField,
 )
 from ...tensor.random import RandomStateField
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
@@ -41,6 +42,11 @@ class DataFrameSample(DataFrameOperator, DataFrameOperatorMixin):
     axis = Int8Field("axis", default=None)
     seed = Int64Field("seed", default=None)
     random_state = RandomStateField("random_state", default=None)
+    always_multinomial = BoolField("always_multinomial", default=None)
+
+    # for chunks
+    # num of instances for chunks
+    chunk_samples = KeyField("chunk_samples", default=None)
 
     def __init__(self, random_state=None, seed=None, **kw):
         if random_state is None:
@@ -54,6 +60,8 @@ class DataFrameSample(DataFrameOperator, DataFrameOperatorMixin):
         next(it)
         if isinstance(op.weights, ENTITY_TYPE):
             op.weights = next(it)
+        if isinstance(op.chunk_samples, ENTITY_TYPE):
+            op.chunk_samples = next(it)
 
     def __call__(self, df):
         params = df.params

maxframe/dataframe/indexing/setitem.py

@@ -23,7 +23,7 @@ from ...core import EntityData, OutputType
 from ...serialization.serializables import AnyField, KeyField
 from ...tensor.core import TENSOR_TYPE
 from ...utils import pd_release_version
-from ..core import DATAFRAME_TYPE, SERIES_TYPE, DataFrame
+from ..core import DATAFRAME_TYPE, ENTITY_TYPE, SERIES_TYPE, DataFrame
 from ..initializer import DataFrame as asframe
 from ..initializer import Series as asseries
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
@@ -77,7 +77,7 @@ class DataFrameSetitem(DataFrameOperator, DataFrameOperatorMixin):
                 value_dtype = pd.Series(list(value.dtypes), index=self.indexes)
             elif is_list_like(value) or isinstance(value, TENSOR_TYPE):
                 # convert to numpy to get actual dim and shape
-                if is_list_like(value):
+                if is_list_like(value) and not isinstance(value, ENTITY_TYPE):
                     value = np.array(value)
 
                 if value.ndim == 1:
@@ -108,7 +108,7 @@ class DataFrameSetitem(DataFrameOperator, DataFrameOperatorMixin):
 
         try:
             dtypes.loc[self.indexes] = value_dtype
-        except KeyError:
+        except (AttributeError, KeyError):
             # when some index not exist, try update one by one
             if isinstance(value_dtype, pd.Series):
                 for idx in self.indexes:

maxframe/dataframe/indexing/swaplevel.py

@@ -0,0 +1,185 @@
+# 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 pandas as pd
+
+from ..utils import validate_axis
+
+
+def _swaplevel(df_or_series, i=-2, j=-1, axis=0):
+    axis = validate_axis(axis, df_or_series)
+
+    if axis == 0:
+        src_idx_value = df_or_series.index_value
+    else:
+        src_idx_value = df_or_series.columns_value
+
+    pd_index = src_idx_value.to_pandas()
+    if not isinstance(pd_index, pd.MultiIndex):
+        raise ValueError("swaplevel can only be used with MultiIndex")
+
+    name_to_idx = {name: idx for idx, name in enumerate(pd_index.names)}
+    src_idx, dest_idx = name_to_idx.get(i, i), name_to_idx.get(j, j)
+
+    new_idxes = list(range(len(pd_index.names)))
+    new_idxes[src_idx], new_idxes[dest_idx] = new_idxes[dest_idx], new_idxes[src_idx]
+    if df_or_series.ndim == 2:
+        return df_or_series.reorder_levels(new_idxes, axis=axis)
+    else:
+        return df_or_series.reorder_levels(new_idxes)
+
+
+def df_swaplevel(df, i=-2, j=-1, axis=0):
+    """
+    Swap levels i and j in a :class:`MultiIndex`.
+
+    Default is to swap the two innermost levels of the index.
+
+    Parameters
+    ----------
+    i, j : int or str
+        Levels of the indices to be swapped. Can pass level name as string.
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+                The axis to swap levels on. 0 or 'index' for row-wise, 1 or
+                'columns' for column-wise.
+
+    Returns
+    -------
+    DataFrame
+        DataFrame with levels swapped in MultiIndex.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame(
+    ...     {"Grade": ["A", "B", "A", "C"]},
+    ...     index=[
+    ...         ["Final exam", "Final exam", "Coursework", "Coursework"],
+    ...         ["History", "Geography", "History", "Geography"],
+    ...         ["January", "February", "March", "April"],
+    ...     ],
+    ... )
+    >>> df.execute()
+                                        Grade
+    Final exam  History     January      A
+                Geography   February     B
+    Coursework  History     March        A
+                Geography   April        C
+
+    In the following example, we will swap the levels of the indices.
+    Here, we will swap the levels column-wise, but levels can be swapped row-wise
+    in a similar manner. Note that column-wise is the default behaviour.
+    By not supplying any arguments for i and j, we swap the last and second to
+    last indices.
+
+    >>> df.swaplevel().execute()
+                                        Grade
+    Final exam  January     History         A
+                February    Geography       B
+    Coursework  March       History         A
+                April       Geography       C
+
+    By supplying one argument, we can choose which index to swap the last
+    index with. We can for example swap the first index with the last one as
+    follows.
+
+    >>> df.swaplevel(0).execute()
+                                        Grade
+    January     History     Final exam      A
+    February    Geography   Final exam      B
+    March       History     Coursework      A
+    April       Geography   Coursework      C
+
+    We can also define explicitly which indices we want to swap by supplying values
+    for both i and j. Here, we for example swap the first and second indices.
+
+    >>> df.swaplevel(0, 1).execute()
+                                        Grade
+    History     Final exam  January         A
+    Geography   Final exam  February        B
+    History     Coursework  March           A
+    Geography   Coursework  April           C
+    """
+    return _swaplevel(df, i, j, axis=axis)
+
+
+def series_swaplevel(series, i=-2, j=-1):
+    """
+    Swap levels i and j in a :class:`MultiIndex`.
+
+    Default is to swap the two innermost levels of the index.
+
+    Parameters
+    ----------
+    i, j : int or str
+        Levels of the indices to be swapped. Can pass level name as string.
+
+    Returns
+    -------
+    Series
+        Series with levels swapped in MultiIndex.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series(
+    ...     ["A", "B", "A", "C"],
+    ...     index=[
+    ...         ["Final exam", "Final exam", "Coursework", "Coursework"],
+    ...         ["History", "Geography", "History", "Geography"],
+    ...         ["January", "February", "March", "April"],
+    ...     ],
+    ... )
+    >>> s.execute()
+    Final exam  History     January      A
+                Geography   February     B
+    Coursework  History     March        A
+                Geography   April        C
+    dtype: object
+
+    In the following example, we will swap the levels of the indices.
+    Here, we will swap the levels column-wise, but levels can be swapped row-wise
+    in a similar manner. Note that column-wise is the default behaviour.
+    By not supplying any arguments for i and j, we swap the last and second to
+    last indices.
+
+    >>> s.swaplevel().execute()
+    Final exam  January     History         A
+                February    Geography       B
+    Coursework  March       History         A
+                April       Geography       C
+    dtype: object
+
+    By supplying one argument, we can choose which index to swap the last
+    index with. We can for example swap the first index with the last one as
+    follows.
+
+    >>> s.swaplevel(0).execute()
+    January     History     Final exam      A
+    February    Geography   Final exam      B
+    March       History     Coursework      A
+    April       Geography   Coursework      C
+    dtype: object
+
+    We can also define explicitly which indices we want to swap by supplying values
+    for both i and j. Here, we for example swap the first and second indices.
+
+    >>> s.swaplevel(0, 1).execute()
+    History     Final exam  January         A
+    Geography   Final exam  February        B
+    History     Coursework  March           A
+    Geography   Coursework  April           C
+    dtype: object
+    """
+    return _swaplevel(series, i, j)

maxframe/dataframe/indexing/take.py

@@ -0,0 +1,99 @@
+# 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 ..utils import validate_axis
+
+
+def take(df_or_series, indices, axis=0, **kwargs):
+    """
+    Return the elements in the given *positional* indices along an axis.
+
+    This means that we are not indexing according to actual values in
+    the index attribute of the object. We are indexing according to the
+    actual position of the element in the object.
+
+    Parameters
+    ----------
+    indices : array-like
+        An array of ints indicating which positions to take.
+    axis : {0 or 'index', 1 or 'columns', None}, default 0
+        The axis on which to select elements. ``0`` means that we are
+        selecting rows, ``1`` means that we are selecting columns.
+        For `Series` this parameter is unused and defaults to 0.
+    **kwargs
+        For compatibility with :meth:`numpy.take`. Has no effect on the
+        output.
+
+    Returns
+    -------
+    same type as caller
+        An array-like containing the elements taken from the object.
+
+    See Also
+    --------
+    DataFrame.loc : Select a subset of a DataFrame by labels.
+    DataFrame.iloc : Select a subset of a DataFrame by positions.
+    numpy.take : Take elements from an array along an axis.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([('falcon', 'bird', 389.0),
+    ...                    ('parrot', 'bird', 24.0),
+    ...                    ('lion', 'mammal', 80.5),
+    ...                    ('monkey', 'mammal', mt.nan)],
+    ...                   columns=['name', 'class', 'max_speed'],
+    ...                   index=[0, 2, 3, 1])
+    >>> df.execute()
+         name   class  max_speed
+    0  falcon    bird      389.0
+    2  parrot    bird       24.0
+    3    lion  mammal       80.5
+    1  monkey  mammal        NaN
+
+    Take elements at positions 0 and 3 along the axis 0 (default).
+
+    Note how the actual indices selected (0 and 1) do not correspond to
+    our selected indices 0 and 3. That's because we are selecting the 0th
+    and 3rd rows, not rows whose indices equal 0 and 3.
+
+    >>> df.take([0, 3]).execute()
+         name   class  max_speed
+    0  falcon    bird      389.0
+    1  monkey  mammal        NaN
+
+    Take elements at indices 1 and 2 along the axis 1 (column selection).
+
+    >>> df.take([1, 2], axis=1).execute()
+        class  max_speed
+    0    bird      389.0
+    2    bird       24.0
+    3  mammal       80.5
+    1  mammal        NaN
+
+    We may take elements using negative integers for positive indices,
+    starting from the end of the object, just like with Python lists.
+
+    >>> df.take([-1, -2]).execute()
+         name   class  max_speed
+    1  monkey  mammal        NaN
+    3    lion  mammal       80.5
+    """
+    kwargs.clear()
+
+    axis = validate_axis(axis, df_or_series)
+    slc = [slice(None), slice(None)][: df_or_series.ndim]
+    slc[axis] = indices
+    return df_or_series.iloc[tuple(slc)]