maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/indexing/sample.py

@@ -0,0 +1,232 @@
+# 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 copy
+from typing import List
+
+import numpy as np
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, EntityData, get_output_types
+from ...serialization.serializables import (
+    AnyField,
+    BoolField,
+    Float64Field,
+    Int8Field,
+    Int64Field,
+    KeyField,
+)
+from ...tensor.random import RandomStateField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+
+class DataFrameSample(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.RAND_SAMPLE
+
+    size = Int64Field("size", default=None)
+    frac = Float64Field("frac", default=None)
+    replace = BoolField("replace", default=False)
+    weights = AnyField("weights", default=None)
+    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:
+            random_state = np.random.RandomState(seed)
+        super().__init__(random_state=random_state, seed=seed, **kw)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameSample", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        it = iter(inputs)
+        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
+        new_shape = list(df.shape)
+
+        if self.size is not None:
+            new_shape[self.axis] = self.size
+        elif self.frac is not None:
+            new_shape[self.axis] = np.nan
+
+        params["shape"] = tuple(new_shape)
+        params["index_value"] = parse_index(df.index_value.to_pandas()[:0])
+
+        input_dfs = [df]
+        if isinstance(self.weights, ENTITY_TYPE):
+            input_dfs.append(self.weights)
+
+        self._output_types = get_output_types(df)
+        return self.new_tileable(input_dfs, **params)
+
+
+def sample(
+    df_or_series,
+    n=None,
+    frac=None,
+    replace=False,
+    weights=None,
+    random_state=None,
+    axis=None,
+    always_multinomial=False,
+):
+    """
+    Return a random sample of items from an axis of object.
+
+    You can use `random_state` for reproducibility.
+
+    Parameters
+    ----------
+    n : int, optional
+        Number of items from axis to return. Cannot be used with `frac`.
+        Default = 1 if `frac` = None.
+    frac : float, optional
+        Fraction of axis items to return. Cannot be used with `n`.
+    replace : bool, default False
+        Allow or disallow sampling of the same row more than once.
+    weights : str or ndarray-like, optional
+        Default 'None' results in equal probability weighting.
+        If passed a Series, will align with target object on index. Index
+        values in weights not found in sampled object will be ignored and
+        index values in sampled object not in weights will be assigned
+        weights of zero.
+        If called on a DataFrame, will accept the name of a column
+        when axis = 0.
+        Unless weights are a Series, weights must be same length as axis
+        being sampled.
+        If weights do not sum to 1, they will be normalized to sum to 1.
+        Missing values in the weights column will be treated as zero.
+        Infinite values not allowed.
+    random_state : int, array-like, BitGenerator, np.random.RandomState, optional
+        If int, array-like, or BitGenerator (NumPy>=1.17), seed for
+        random number generator
+        If np.random.RandomState, use as numpy RandomState object.
+    axis : {0 or ‘index’, 1 or ‘columns’, None}, default None
+        Axis to sample. Accepts axis number or name. Default is stat axis
+        for given data type (0 for Series and DataFrames).
+    always_multinomial : bool, default False
+        If True, always treat distribution of sample counts between data chunks
+        as multinomial distribution. This will accelerate sampling when data
+        is huge, but may affect randomness of samples when number of instances
+        is not very large.
+
+    Returns
+    -------
+    Series or DataFrame
+        A new object of same type as caller containing `n` items randomly
+        sampled from the caller object.
+
+    See Also
+    --------
+    DataFrameGroupBy.sample: Generates random samples from each group of a
+        DataFrame object.
+    SeriesGroupBy.sample: Generates random samples from each group of a
+        Series object.
+    numpy.random.choice: Generates a random sample from a given 1-D numpy
+        array.
+
+    Notes
+    -----
+    If `frac` > 1, `replacement` should be set to `True`.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'num_legs': [2, 4, 8, 0],
+    ...                    'num_wings': [2, 0, 0, 0],
+    ...                    'num_specimen_seen': [10, 2, 1, 8]},
+    ...                   index=['falcon', 'dog', 'spider', 'fish'])
+    >>> df.execute()
+            num_legs  num_wings  num_specimen_seen
+    falcon         2          2                 10
+    dog            4          0                  2
+    spider         8          0                  1
+    fish           0          0                  8
+
+    Extract 3 random elements from the ``Series`` ``df['num_legs']``:
+    Note that we use `random_state` to ensure the reproducibility of
+    the examples.
+
+    >>> df['num_legs'].sample(n=3, random_state=1).execute()
+    fish      0
+    spider    8
+    falcon    2
+    Name: num_legs, dtype: int64
+
+    A random 50% sample of the ``DataFrame`` with replacement:
+
+    >>> df.sample(frac=0.5, replace=True, random_state=1).execute()
+          num_legs  num_wings  num_specimen_seen
+    dog          4          0                  2
+    fish         0          0                  8
+
+    An upsample sample of the ``DataFrame`` with replacement:
+    Note that `replace` parameter has to be `True` for `frac` parameter > 1.
+
+    >>> df.sample(frac=2, replace=True, random_state=1).execute()
+            num_legs  num_wings  num_specimen_seen
+    dog            4          0                  2
+    fish           0          0                  8
+    falcon         2          2                 10
+    falcon         2          2                 10
+    fish           0          0                  8
+    dog            4          0                  2
+    fish           0          0                  8
+    dog            4          0                  2
+
+    Using a DataFrame column as weights. Rows with larger value in the
+    `num_specimen_seen` column are more likely to be sampled.
+
+    >>> df.sample(n=2, weights='num_specimen_seen', random_state=1).execute()
+            num_legs  num_wings  num_specimen_seen
+    falcon         2          2                 10
+    fish           0          0                  8
+    """
+    if frac and n:
+        raise ValueError("Please enter a value for `frac` OR `n`, not both.")
+
+    axis = validate_axis(axis or 0, df_or_series)
+    if axis == 1:
+        raise NotImplementedError("Currently cannot sample over columns")
+    if frac is not None and frac < 0 or n is not None and n < 0:
+        raise ValueError(
+            "A negative number of rows requested. Please provide positive value."
+        )
+    rs = copy.deepcopy(
+        random_state.to_numpy() if hasattr(random_state, "to_numpy") else random_state
+    )
+    if isinstance(rs, (int, np.ndarray)):
+        rs = np.random.RandomState(rs)
+    op = DataFrameSample(
+        size=n,
+        frac=frac,
+        replace=replace,
+        weights=weights,
+        random_state=rs,
+        axis=axis,
+        always_multinomial=always_multinomial,
+    )
+    return op(df_or_series)

maxframe/dataframe/indexing/set_axis.py

@@ -0,0 +1,197 @@
+# 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 ... import opcodes
+from ...core import ENTITY_TYPE, EntityData, get_output_types
+from ...serialization.serializables import AnyField, Int8Field, KeyField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+
+class DataFrameSetAxis(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DATAFRAME_SET_AXIS
+
+    input = KeyField("input", default=None)
+    axis = Int8Field("axis", default=None)
+    value = AnyField("value", default=None)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameSetAxis", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.input = inputs[0]
+        if isinstance(op.value, ENTITY_TYPE):
+            op.value = inputs[-1]
+
+    def __call__(self, df_or_series):
+        new_size = self.value.shape[0]
+        expect_size = df_or_series.axes[self.axis].shape[0]
+        if (
+            not np.isnan(new_size)
+            and not np.isnan(expect_size)
+            and new_size != expect_size
+        ):
+            raise ValueError(
+                f"Length mismatch: Expected axis has {expect_size} elements, "
+                f"new values have {new_size} elements"
+            )
+
+        params = df_or_series.params
+        if self.axis == 0:
+            params["index_value"] = (
+                parse_index(self.value)
+                if isinstance(self.value, pd.Index)
+                else self.value.index_value
+            )
+        else:
+            params["columns_value"] = (
+                parse_index(self.value, store_data=True)
+                if isinstance(self.value, pd.Index)
+                else self.value.index_value
+            )
+            pd_columns = (
+                self.value.index_value.to_pandas()
+                if isinstance(self.value, ENTITY_TYPE)
+                else self.value
+            )
+            params["dtypes"] = params["dtypes"].set_axis(pd_columns)
+
+        self._output_types = get_output_types(df_or_series)
+        inputs = [df_or_series]
+        if isinstance(self.value, ENTITY_TYPE):
+            inputs += [self.value]
+        return self.new_tileable(inputs, **params)
+
+
+def _set_axis(df_or_axis, labels, axis=0, inplace=False):
+    axis = validate_axis(axis, df_or_axis)
+    if not isinstance(labels, ENTITY_TYPE) and not isinstance(labels, pd.Index):
+        labels = pd.Index(labels)
+
+    op = DataFrameSetAxis(value=labels, axis=axis)
+    result = op(df_or_axis)
+    if inplace:
+        df_or_axis.data = result.data
+    else:
+        return result
+
+
+def df_set_axis(df, labels, axis=0, inplace=False):
+    """
+    Assign desired index to given axis.
+
+    Indexes for column or row labels can be changed by assigning
+    a list-like or Index.
+
+    Parameters
+    ----------
+    labels : list-like, Index
+        The values for the new index.
+
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        The axis to update. The value 0 identifies the rows, and 1 identifies the columns.
+
+    inplace : bool, default False
+        Whether to return a new DataFrame instance.
+
+    Returns
+    -------
+    renamed : DataFrame or None
+        An object of type DataFrame or None if ``inplace=True``.
+
+    See Also
+    --------
+    DataFrame.rename_axis : Alter the name of the index or columns.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+
+    Change the row labels.
+
+    >>> df.set_axis(['a', 'b', 'c'], axis='index').execute()
+       A  B
+    a  1  4
+    b  2  5
+    c  3  6
+
+    Change the column labels.
+
+    >>> df.set_axis(['I', 'II'], axis='columns').execute()
+       I  II
+    0  1   4
+    1  2   5
+    2  3   6
+
+    Now, update the labels inplace.
+
+    >>> df.set_axis(['i', 'ii'], axis='columns', inplace=True)
+    >>> df.execute()
+       i  ii
+    0  1   4
+    1  2   5
+    2  3   6
+    """
+    return _set_axis(df, labels, axis=axis, inplace=inplace)
+
+
+def series_set_axis(series, labels, axis=0, inplace=False):
+    """
+    Assign desired index to given axis.
+
+    Indexes for row labels can be changed by assigning
+    a list-like or Index.
+
+    Parameters
+    ----------
+    labels : list-like, Index
+        The values for the new index.
+
+    axis : {0 or 'index'}, default 0
+        The axis to update. The value 0 identifies the rows.
+
+    inplace : bool, default False
+        Whether to return a new Series instance.
+
+    Returns
+    -------
+    renamed : Series or None
+        An object of type Series or None if ``inplace=True``.
+
+    See Also
+    --------
+    Series.rename_axis : Alter the name of the index.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3])
+    >>> s.execute()
+    0    1
+    1    2
+    2    3
+    dtype: int64
+
+    >>> s.set_axis(['a', 'b', 'c'], axis=0).execute()
+    a    1
+    b    2
+    c    3
+    dtype: int64
+    """
+    return _set_axis(series, labels, axis=axis, inplace=inplace)

maxframe/dataframe/indexing/set_index.py

@@ -0,0 +1,128 @@
+# 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 ...core import OutputType
+from ...serialization.serializables import AnyField, BoolField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_empty_df, parse_index
+
+
+class DataFrameSetIndex(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DATAFRAME_SET_INDEX
+
+    keys = AnyField("keys")
+    drop = BoolField("drop", default=True)
+    append = BoolField("append", default=False)
+    verify_integrity = BoolField("verify_integrity", default=False)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def __call__(self, df):
+        new_df = build_empty_df(df.dtypes, index=df.index_value.to_pandas()).set_index(
+            keys=self.keys,
+            drop=self.drop,
+            append=self.append,
+            verify_integrity=self.verify_integrity,
+        )
+        return self.new_dataframe(
+            [df],
+            shape=(df.shape[0], new_df.shape[1]),
+            dtypes=new_df.dtypes,
+            index_value=parse_index(new_df.index),
+            columns_value=parse_index(new_df.columns, store_data=True),
+        )
+
+
+def set_index(df, keys, drop=True, append=False, inplace=False, verify_integrity=False):
+    # TODO add support for set index by series, index, mt.ndarray, etc.
+    """
+    Set the DataFrame index using existing columns.
+
+    Set the DataFrame index (row labels) using one or more existing
+    columns. The index can replace the existing index or expand on it.
+
+    Parameters
+    ----------
+    keys : label or array-like or list of labels
+        This parameter can be either a single column key, or a list containing column keys.
+    drop : bool, default True
+        Delete columns to be used as the new index.
+    append : bool, default False
+        Whether to append columns to existing index.
+    inplace : bool, default False
+        If True, modifies the DataFrame in place (do not create a new object).
+    verify_integrity : bool, default False
+        Check the new index for duplicates. Otherwise defer the check until
+        necessary. Setting to False will improve the performance of this
+        method.
+
+    Returns
+    -------
+    DataFrame or None
+        Changed row labels or None if ``inplace=True``.
+
+    See Also
+    --------
+    DataFrame.reset_index : Opposite of set_index.
+    DataFrame.reindex : Change to new indices or expand indices.
+    DataFrame.reindex_like : Change to same indices as other DataFrame.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+
+    >>> df = md.DataFrame({'month': [1, 4, 7, 10],
+    ...                    'year': [2012, 2014, 2013, 2014],
+    ...                    'sale': [55, 40, 84, 31]})
+    >>> df
+       month  year  sale
+    0      1  2012    55
+    1      4  2014    40
+    2      7  2013    84
+    3     10  2014    31
+
+    Set the index to become the 'month' column:
+
+    >>> df.set_index('month')
+           year  sale
+    month
+    1      2012    55
+    4      2014    40
+    7      2013    84
+    10     2014    31
+
+    Create a MultiIndex using columns 'year' and 'month':
+
+    >>> df.set_index(['year', 'month'])
+                sale
+    year  month
+    2012  1     55
+    2014  4     40
+    2013  7     84
+    2014  10    31
+    """
+    op = DataFrameSetIndex(
+        keys=keys,
+        drop=drop,
+        append=append,
+        verify_integrity=verify_integrity,
+        output_types=[OutputType.dataframe],
+    )
+    result = op(df)
+    if not inplace:
+        return result
+    else:
+        df.data = result.data

maxframe/dataframe/indexing/setitem.py

@@ -0,0 +1,133 @@
+# 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, KeyField
+from ...tensor.core import TENSOR_TYPE
+from ...utils import pd_release_version
+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
+from ..utils import parse_index
+
+# in pandas 1.0.x, __setitem__ with a list with missing items are not allowed
+_allow_set_missing_list = pd_release_version[:2] >= (1, 1)
+
+
+class DataFrameSetitem(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.INDEXSETVALUE
+
+    target = KeyField("target")
+    indexes = AnyField("indexes", default=None)
+    value = AnyField("value", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+        if self.output_types is None:
+            self.output_types = [OutputType.dataframe]
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameSetitem", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.target = op._inputs[0]
+        if len(inputs) > 1:
+            op.value = op._inputs[-1]
+
+    @staticmethod
+    def _is_scalar_tensor(t):
+        return isinstance(t, TENSOR_TYPE) and t.ndim == 0
+
+    def __call__(self, target: DataFrame, value):
+        raw_target = target
+
+        inputs = [target]
+        if np.isscalar(value):
+            value_dtype = np.array(value).dtype
+        elif self._is_scalar_tensor(value):
+            inputs.append(value)
+            value_dtype = value.dtype
+        else:
+            if isinstance(value, (pd.Series, SERIES_TYPE)):
+                value = asseries(value)
+                value_dtype = value.dtype
+            elif isinstance(value, (pd.DataFrame, DATAFRAME_TYPE)):
+                if len(self.indexes) != value.shape[1]:  # pragma: no cover
+                    raise ValueError("Columns must be same length as key")
+
+                value = asframe(value)
+                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) and not isinstance(value, ENTITY_TYPE):
+                    value = np.array(value)
+
+                if value.ndim == 1:
+                    value = asseries(value, index=target.index)
+                    value_dtype = value.dtype
+                else:
+                    if len(self.indexes) != value.shape[1]:  # pragma: no cover
+                        raise ValueError("Columns must be same length as key")
+
+                    value = asframe(value, index=target.index)
+                    value_dtype = pd.Series(list(value.dtypes), index=self.indexes)
+            else:  # pragma: no cover
+                raise TypeError(
+                    "Wrong value type, could be one of scalar, Series or tensor"
+                )
+
+            if target.shape[0] == 0:
+                # target empty, reindex target first
+                target = target.reindex(value.index)
+                inputs[0] = target
+            elif value.index_value.key != target.index_value.key:
+                # need reindex when target df is not empty and index different
+                value = value.reindex(target.index)
+            inputs.append(value)
+
+        index_value = target.index_value
+        dtypes = target.dtypes.copy(deep=True)
+
+        try:
+            dtypes.loc[self.indexes] = value_dtype
+        except (AttributeError, KeyError):
+            # when some index not exist, try update one by one
+            if isinstance(value_dtype, pd.Series):
+                for idx in self.indexes:
+                    dtypes.loc[idx] = value_dtype.loc[idx]
+            else:
+                for idx in self.indexes:
+                    dtypes.loc[idx] = value_dtype
+
+        columns_value = parse_index(dtypes.index, store_data=True)
+        ret = self.new_dataframe(
+            inputs,
+            shape=(target.shape[0], len(dtypes)),
+            dtypes=dtypes,
+            index_value=index_value,
+            columns_value=columns_value,
+        )
+        raw_target.data = ret.data
+
+
+def dataframe_setitem(df, col, value):
+    op = DataFrameSetitem(target=df, indexes=col, value=value)
+    return op(df, value)