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

maxframe/dataframe/merge/update.py

@@ -0,0 +1,271 @@
+# 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 get_output_types
+from ...serialization.serializables import BoolField, StringField
+from ...udf import BuiltinFunction
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+
+class DataFrameUpdate(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DATAFRAME_UPDATE
+
+    join = StringField("join", default=None)
+    overwrite = BoolField("overwrite", default=None)
+    filter_func = BoolField("filter_func", default=None)
+    errors = StringField("errors", default=None)
+
+    def __init__(self, output_types=None, **kwargs):
+        super().__init__(_output_types=output_types, **kwargs)
+
+    def has_custom_code(self) -> bool:
+        return not isinstance(self.filter_func, BuiltinFunction)
+
+    def __call__(self, df_or_series, other):
+        self._output_types = get_output_types(df_or_series)
+
+        index_tokenize_objects = [
+            df_or_series,
+            other,
+            self.join,
+            self.overwrite,
+            self.filter_func,
+            self.errors,
+        ]
+
+        # Return the original object (update is in-place)
+        if df_or_series.ndim == 2:
+            return self.new_dataframe(
+                [df_or_series, other],
+                shape=df_or_series.shape,
+                dtypes=df_or_series.dtypes,
+                index_value=parse_index(
+                    df_or_series.index_value.to_pandas(), *index_tokenize_objects
+                ),
+                columns_value=df_or_series.columns_value,
+            )
+        else:
+            return self.new_series(
+                [df_or_series, other],
+                shape=df_or_series.shape,
+                dtype=df_or_series.dtype,
+                index_value=parse_index(
+                    df_or_series.index_value.to_pandas(), *index_tokenize_objects
+                ),
+                name=df_or_series.name,
+            )
+
+
+def _update(
+    df_or_series, other, join="left", overwrite=True, filter_func=None, errors="ignore"
+):
+    op = DataFrameUpdate(
+        join=join,
+        overwrite=overwrite,
+        filter_func=filter_func,
+        errors=errors,
+    )
+    result = op(df_or_series, other)
+    df_or_series.data = result.data
+
+
+def df_update(
+    df, other, join="left", overwrite=True, filter_func=None, errors="ignore"
+):
+    """
+    Modify in place using non-NA values from another DataFrame.
+
+    Aligns on indices. There is no return value.
+
+    Parameters
+    ----------
+    other : DataFrame, or object coercible into a DataFrame
+        Should have at least one matching index/column label
+        with the original DataFrame. If a Series is passed,
+        its name attribute must be set, and that will be
+        used as the column name to align with the original DataFrame.
+    join : {'left'}, default 'left'
+        Only left join is implemented, keeping the index and columns of the
+        original object.
+    overwrite : bool, default True
+        How to handle non-NA values for overlapping keys:
+
+        * True: overwrite original DataFrame's values
+          with values from `other`.
+        * False: only update values that are NA in
+          the original DataFrame.
+
+    filter_func : callable(1d-array) -> bool 1d-array, optional
+        Can choose to replace values other than NA. Return True for values
+        that should be updated.
+    errors : {'raise', 'ignore'}, default 'ignore'
+        If 'raise', will raise a ValueError if the DataFrame and `other`
+        both contain non-NA data in the same place.
+
+    Returns
+    -------
+    None
+        This method directly changes calling object.
+
+    Raises
+    ------
+    ValueError
+        * When `errors='raise'` and there's overlapping non-NA data.
+        * When `errors` is not either `'ignore'` or `'raise'`
+    NotImplementedError
+        * If `join != 'left'`
+
+    See Also
+    --------
+    dict.update : Similar method for dictionaries.
+    DataFrame.merge : For column(s)-on-column(s) operations.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'A': [1, 2, 3],
+    ...                    'B': [400, 500, 600]})
+    >>> new_df = md.DataFrame({'B': [4, 5, 6],
+    ...                        'C': [7, 8, 9]})
+    >>> df.update(new_df)
+    >>> df.execute()
+       A  B
+    0  1  4
+    1  2  5
+    2  3  6
+
+    The DataFrame's length does not increase as a result of the update,
+    only values at matching index/column labels are updated.
+
+    >>> df = md.DataFrame({'A': ['a', 'b', 'c'],
+    ...                    'B': ['x', 'y', 'z']})
+    >>> new_df = md.DataFrame({'B': ['d', 'e', 'f', 'g', 'h', 'i']})
+    >>> df.update(new_df)
+    >>> df.execute()
+       A  B
+    0  a  d
+    1  b  e
+    2  c  f
+
+    >>> df = md.DataFrame({'A': ['a', 'b', 'c'],
+    ...                    'B': ['x', 'y', 'z']})
+    >>> new_df = md.DataFrame({'B': ['d', 'f']}, index=[0, 2])
+    >>> df.update(new_df)
+    >>> df.execute()
+       A  B
+    0  a  d
+    1  b  y
+    2  c  f
+
+    For Series, its name attribute must be set.
+
+    >>> df = md.DataFrame({'A': ['a', 'b', 'c'],
+    ...                    'B': ['x', 'y', 'z']})
+    >>> new_column = md.Series(['d', 'e', 'f'], name='B')
+    >>> df.update(new_column)
+    >>> df.execute()
+       A  B
+    0  a  d
+    1  b  e
+    2  c  f
+
+    If `other` contains NaNs the corresponding values are not updated
+    in the original dataframe.
+
+    >>> df = md.DataFrame({'A': [1, 2, 3],
+    ...                    'B': [400., 500., 600.]})
+    >>> new_df = md.DataFrame({'B': [4, mt.nan, 6]})
+    >>> df.update(new_df)
+    >>> df.execute()
+       A      B
+    0  1    4.0
+    1  2  500.0
+    2  3    6.0
+    """
+    return _update(df, other, join, overwrite, filter_func, errors)
+
+
+def series_update(series, other):
+    """
+    Modify Series in place using values from passed Series.
+
+    Uses non-NA values from passed Series to make updates. Aligns
+    on index.
+
+    Parameters
+    ----------
+    other : Series, or object coercible into Series
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3])
+    >>> s.update(md.Series([4, 5, 6]))
+    >>> s.execute()
+    0    4
+    1    5
+    2    6
+    dtype: int64
+
+    >>> s = md.Series(['a', 'b', 'c'])
+    >>> s.update(md.Series(['d', 'e'], index=[0, 2]))
+    >>> s.execute()
+    0    d
+    1    b
+    2    e
+    dtype: object
+
+    >>> s = md.Series([1, 2, 3])
+    >>> s.update(md.Series([4, 5, 6, 7, 8]))
+    >>> s.execute()
+    0    4
+    1    5
+    2    6
+    dtype: int64
+
+    If ``other`` contains NaNs the corresponding values are not updated
+    in the original Series.
+
+    >>> s = md.Series([1, 2, 3])
+    >>> s.update(md.Series([4, mt.nan, 6]))
+    >>> s.execute()
+    0    4
+    1    2
+    2    6
+    dtype: int64
+
+    ``other`` can also be a non-Series object type
+    that is coercible into a Series
+
+    >>> s = md.Series([1, 2, 3])
+    >>> s.update([4, mt.nan, 6])
+    >>> s.execute()
+    0    4
+    1    2
+    2    6
+    dtype: int64
+
+    >>> s = md.Series([1, 2, 3])
+    >>> s.update({1: 9})
+    >>> s.execute()
+    0    1
+    1    9
+    2    3
+    dtype: int64
+    """
+    return _update(series, other)

maxframe/dataframe/misc/__init__.py

@@ -21,10 +21,12 @@ from .check_monotonic import (
     is_monotonic_decreasing,
     is_monotonic_increasing,
 )
+from .check_unique import index_is_unique, series_is_unique
+from .clip import clip
 from .cut import cut
 from .describe import describe
 from .diff import df_diff, series_diff
-from .drop import df_drop, df_pop, index_drop, series_drop
+from .drop import df_drop, df_pop, index_drop, series_drop, series_pop
 from .drop_duplicates import (
     df_drop_duplicates,
     index_drop_duplicates,
@@ -33,21 +35,20 @@ from .drop_duplicates import (
 from .duplicated import df_duplicated, index_duplicated, series_duplicated
 from .eval import df_eval, df_query
 from .explode import df_explode, series_explode
+from .infer_dtypes import convert_dtypes, infer_objects
 from .isin import df_isin, series_isin
-from .map import index_map, series_map
-from .melt import melt
+from .map import df_map, index_map, series_map
 from .memory_usage import df_memory_usage, index_memory_usage, series_memory_usage
 from .pct_change import pct_change
-from .pivot import pivot
-from .pivot_table import pivot_table
 from .qcut import qcut
 from .rechunk import rechunk
+from .repeat import index_repeat, series_repeat
 from .select_dtypes import select_dtypes
 from .shift import shift, tshift
-from .stack import stack
 from .transform import df_transform, series_transform
 from .transpose import transpose
-from .value_counts import value_counts
+from .valid_index import first_valid_index, last_valid_index
+from .value_counts import df_value_counts, value_counts
 
 
 def _install():
@@ -55,7 +56,10 @@ def _install():
 
     for t in DATAFRAME_TYPE:
         setattr(t, "apply", df_apply)
+        setattr(t, "applymap", df_map)
         setattr(t, "astype", astype)
+        setattr(t, "clip", clip)
+        setattr(t, "convert_dtypes", convert_dtypes)
         setattr(t, "describe", describe)
         setattr(
             t, "__delitem__", lambda df, items: df_drop(df, items, axis=1, inplace=True)
@@ -66,41 +70,50 @@ def _install():
         setattr(t, "drop", df_drop)
         setattr(t, "eval", df_eval)
         setattr(t, "explode", df_explode)
+        setattr(t, "first_valid_index", first_valid_index)
+        setattr(t, "infer_objects", infer_objects)
         setattr(t, "isin", df_isin)
-        setattr(t, "melt", melt)
+        setattr(t, "last_valid_index", last_valid_index)
+        setattr(t, "map", df_map)
         setattr(t, "memory_usage", df_memory_usage)
         setattr(t, "pct_change", pct_change)
-        setattr(t, "pivot", pivot)
-        setattr(t, "pivot_table", pivot_table)
         setattr(t, "pop", df_pop)
         setattr(t, "query", df_query)
         setattr(t, "rechunk", rechunk)
         setattr(t, "select_dtypes", select_dtypes)
         setattr(t, "shift", shift)
-        setattr(t, "stack", stack)
         setattr(t, "transform", df_transform)
         setattr(t, "transpose", transpose)
         setattr(t, "tshift", tshift)
+        setattr(t, "value_counts", df_value_counts)
 
     for t in SERIES_TYPE:
         setattr(t, "apply", series_apply)
         setattr(t, "astype", astype)
         setattr(t, "case_when", case_when)
         setattr(t, "check_monotonic", check_monotonic)
+        setattr(t, "clip", clip)
+        setattr(t, "convert_dtypes", convert_dtypes)
         setattr(t, "describe", describe)
         setattr(t, "diff", series_diff)
         setattr(t, "drop", series_drop)
         setattr(t, "drop_duplicates", series_drop_duplicates)
         setattr(t, "duplicated", series_duplicated)
         setattr(t, "explode", series_explode)
+        setattr(t, "first_valid_index", first_valid_index)
+        setattr(t, "infer_objects", infer_objects)
         setattr(t, "is_monotonic", property(fget=is_monotonic))
         setattr(t, "is_monotonic_decreasing", property(fget=is_monotonic_decreasing))
         setattr(t, "is_monotonic_increasing", property(fget=is_monotonic_increasing))
         setattr(t, "isin", series_isin)
+        setattr(t, "is_unique", property(fget=series_is_unique))
+        setattr(t, "last_valid_index", last_valid_index)
         setattr(t, "map", series_map)
         setattr(t, "memory_usage", series_memory_usage)
         setattr(t, "pct_change", pct_change)
+        setattr(t, "pop", series_pop)
         setattr(t, "rechunk", rechunk)
+        setattr(t, "repeat", series_repeat)
         setattr(t, "shift", shift)
         setattr(t, "transform", series_transform)
         setattr(t, "tshift", tshift)
@@ -109,15 +122,19 @@ def _install():
     for t in INDEX_TYPE:
         setattr(t, "astype", index_astype)
         setattr(t, "check_monotonic", check_monotonic)
+        setattr(t, "clip", clip)
         setattr(t, "drop", index_drop)
         setattr(t, "drop_duplicates", index_drop_duplicates)
         setattr(t, "duplicated", index_duplicated)
+        setattr(t, "has_duplicates", property(fget=lambda x: not index_is_unique(x)))
         setattr(t, "is_monotonic", property(fget=is_monotonic))
         setattr(t, "is_monotonic_increasing", property(fget=is_monotonic_increasing))
         setattr(t, "is_monotonic_decreasing", property(fget=is_monotonic_decreasing))
+        setattr(t, "is_unique", property(fget=index_is_unique))
         setattr(t, "map", index_map)
         setattr(t, "memory_usage", index_memory_usage)
         setattr(t, "rechunk", rechunk)
+        setattr(t, "repeat", index_repeat)
         setattr(t, "value_counts", value_counts)
 
 

maxframe/dataframe/misc/_duplicate.py

@@ -17,28 +17,34 @@ from typing import List
 import pandas as pd
 from pandas.api.types import is_list_like
 
-from ...core import EntityData
+from ...core import ENTITY_TYPE, EntityData
 from ...core.operator import MapReduceOperator
 from ...serialization.serializables import AnyField, KeyField, StringField
 from ..operators import DataFrameOperatorMixin
 
 
-class DuplicateOperand(MapReduceOperator, DataFrameOperatorMixin):
+class BaseDuplicateOp(MapReduceOperator, DataFrameOperatorMixin):
+    _legacy_name = "DuplicateOperand"  # since 2.2.0
+
     input = KeyField("input")
     subset = AnyField("subset", default=None)
     keep = AnyField("keep", default="first")
     method = StringField("method", default=None)
 
     @classmethod
-    def _set_inputs(cls, op: "DuplicateOperand", inputs: List[EntityData]):
+    def _set_inputs(cls, op: "BaseDuplicateOp", inputs: List[EntityData]):
         super()._set_inputs(op, inputs)
         op.input = op._inputs[0]
 
 
+# keep for import compatibility
+DuplicateOperand = BaseDuplicateOp
+
+
 def validate_subset(df, subset):
     if subset is None:
         return subset
-    if not is_list_like(subset):
+    if not is_list_like(subset) or isinstance(subset, ENTITY_TYPE):
         subset = [subset]
     else:
         subset = list(subset)

maxframe/dataframe/misc/apply.py

@@ -64,7 +64,7 @@ class DataFrameApply(
     DataFrameOperator, DataFrameOperatorMixin, ApplyOperandLogicKeyGeneratorMixin
 ):
     _op_type_ = opcodes.APPLY
-    _legacy_name = "ApplyOperator"
+    _legacy_name = "ApplyOperator"  # since v2.0.0
 
     func = FunctionField("func")
     axis = AnyField("axis", default=0)

maxframe/dataframe/misc/check_unique.py

@@ -0,0 +1,82 @@
+# 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 ...udf import builtin_function
+
+
+@builtin_function
+def _tailor_unique(series_or_idx):
+    if not series_or_idx.is_unique:
+        if isinstance(series_or_idx, pd.Series):
+            return series_or_idx.iloc[:0]
+        else:
+            return series_or_idx[:0]
+    return series_or_idx
+
+
+def _is_unique(series_or_index):
+    from ... import tensor as mt
+
+    return mt.equal(
+        series_or_index.mf.apply_chunk(
+            _tailor_unique, dtype=series_or_index.dtype
+        ).nunique(),
+        mt.shape(series_or_index)[0],
+    )
+
+
+def series_is_unique(series):
+    """
+    Return boolean if values in the object are unique.
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3])
+    >>> s.is_unique.execute()
+    True
+
+    >>> s = md.Series([1, 2, 3, 1])
+    >>> s.is_unique.execute()
+    False
+    """
+    return _is_unique(series)
+
+
+def index_is_unique(index):
+    """
+    Return boolean if values in the index are unique.
+
+    Returns
+    -------
+    bool
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> index = md.Index([1, 2, 3])
+    >>> index.is_unique.execute()
+    True
+
+    >>> index = md.Index([1, 2, 3, 1])
+    >>> index.is_unique.execute()
+    False
+    """
+    return index.to_series().is_unique

maxframe/dataframe/misc/clip.py

@@ -0,0 +1,145 @@
+# 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
+
+from pandas.api.types import is_list_like
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, get_output_types
+from ...serialization.serializables import Int8Field, TupleField
+from ...typing_ import EntityType
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import validate_axis
+
+
+class DataFrameClip(DataFrameOperatorMixin, DataFrameOperator):
+    _op_type_ = opcodes.CLIP
+
+    bounds = TupleField("bounds", default=None)
+    axis = Int8Field("axis", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameClip", inputs: List[EntityType]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(inputs[1:])
+
+        bounds = list(op.bounds)
+        if len(inputs) > 1:
+            for idx in range(len(bounds)):
+                if isinstance(bounds[idx], ENTITY_TYPE):
+                    bounds[idx] = next(inputs_iter)
+        op.bounds = tuple(bounds)
+
+    def __call__(self, df):
+        self._output_types = get_output_types(df)
+        bound_inputs = [bd for bd in self.bounds if isinstance(bd, ENTITY_TYPE)]
+        return self.new_tileable([df] + bound_inputs, **df.params)
+
+
+def clip(df, lower=None, upper=None, *, axis=None, inplace=False):
+    """
+    Trim values at input threshold(s).
+
+    Assigns values outside boundary to boundary values. Thresholds
+    can be singular values or array like, and in the latter case
+    the clipping is performed element-wise in the specified axis.
+
+    Parameters
+    ----------
+    lower : float or array-like, default None
+        Minimum threshold value. All values below this
+        threshold will be set to it. If None, no lower clipping is performed.
+    upper : float or array-like, default None
+        Maximum threshold value. All values above this
+        threshold will be set to it. If None, no upper clipping is performed.
+    axis : int or str axis name, optional
+        Align object with lower and upper along the given axis.
+    inplace : bool, default False
+        Whether to perform the operation in place on the data.
+    *args, **kwargs
+        Additional keywords have no effect but might be accepted
+        for compatibility with numpy.
+
+    Returns
+    -------
+    Series or DataFrame or None
+        Same type as calling object with the values outside the
+        clip boundaries replaced or None if ``inplace=True``.
+
+    See Also
+    --------
+    Series.clip : Trim values at input threshold in series.
+    DataFrame.clip : Trim values at input threshold in dataframe.
+    numpy.clip : Clip (limit) the values in an array.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> data = {'col_0': [9, -3, 0, -1, 5], 'col_1': [-2, -7, 6, 8, -5]}
+    >>> df = md.DataFrame(data)
+    >>> df.execute()
+       col_0  col_1
+    0      9     -2
+    1     -3     -7
+    2      0      6
+    3     -1      8
+    4      5     -5
+
+    Clips per column using lower and upper thresholds:
+
+    >>> df.clip(lower=-4, upper=7).execute()
+       col_0  col_1
+    0      7     -2
+    1     -3     -4
+    2      0      6
+    3     -1      7
+    4      5     -4
+
+    Clips using specific lower and upper thresholds per column element:
+
+    >>> t = md.Series([2, -4, -1, 6, 3])
+    >>> t.execute()
+    0    2
+    1   -4
+    2   -1
+    3    6
+    4    3
+    dtype: int64
+
+    >>> df.clip(lower=t, upper=t).execute()
+       col_0  col_1
+    0      2      2
+    1     -3     -4
+    2      0     -1
+    3     -1      6
+    4      5      3
+    """
+    axis = validate_axis(axis, df) if axis is not None else None
+    if axis is None and any(
+        isinstance(x, ENTITY_TYPE) or is_list_like(x) for x in (lower, upper)
+    ):
+        if df.ndim == 1:
+            axis = 0
+        else:
+            raise ValueError("Must specify axis=0 or 1")
+
+    op = DataFrameClip(bounds=(lower, upper), axis=axis)
+    out = op(df)
+    if inplace:
+        df.data = out.data
+    return out