maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/misc/astype.py

@@ -0,0 +1,237 @@
+# 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 pandas.api.types import CategoricalDtype
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, ListField, StringField
+from ...utils import make_dtypes, pd_release_version
+from ..core import DATAFRAME_TYPE, SERIES_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_empty_df, build_empty_series, parse_index
+
+_need_astype_contiguous = pd_release_version == (1, 3, 0)
+
+
+class DataFrameAstype(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.ASTYPE
+
+    dtype_values = AnyField("dtype_values", default=None)
+    errors = StringField("errors", default=None)
+    category_cols = ListField("category_cols", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def __call__(self, df):
+        if isinstance(df, DATAFRAME_TYPE):
+            empty_df = build_empty_df(df.dtypes)
+            new_df = empty_df.astype(self.dtype_values, errors=self.errors)
+            dtypes = []
+            for dt, new_dt in zip(df.dtypes, new_df.dtypes):
+                if new_dt != dt and isinstance(new_dt, CategoricalDtype):
+                    dtypes.append(CategoricalDtype())
+                else:
+                    dtypes.append(new_dt)
+            dtypes = pd.Series(dtypes, index=new_df.dtypes.index)
+            return self.new_dataframe(
+                [df],
+                shape=df.shape,
+                dtypes=dtypes,
+                index_value=df.index_value,
+                columns_value=df.columns_value,
+            )
+        else:
+            empty_series = build_empty_series(df.dtype)
+            new_series = empty_series.astype(self.dtype_values, errors=self.errors)
+            if new_series.dtype != df.dtype:
+                dtype = (
+                    CategoricalDtype()
+                    if isinstance(new_series.dtype, CategoricalDtype)
+                    else new_series.dtype
+                )
+            else:  # pragma: no cover
+                dtype = df.dtype
+
+            if isinstance(df, SERIES_TYPE):
+                return self.new_series(
+                    [df],
+                    shape=df.shape,
+                    dtype=dtype,
+                    name=df.name,
+                    index_value=df.index_value,
+                )
+            else:
+                new_index = df.index_value.to_pandas().astype(self.dtype_values)
+                new_index_value = parse_index(
+                    new_index, store_data=df.index_value.has_value()
+                )
+                return self.new_index(
+                    [df],
+                    shape=df.shape,
+                    dtype=dtype,
+                    name=df.name,
+                    index_value=new_index_value,
+                )
+
+
+def astype(df, dtype, copy=True, errors="raise"):
+    """
+    Cast a pandas object to a specified dtype ``dtype``.
+
+    Parameters
+    ----------
+    dtype : data type, or dict of column name -> data type
+        Use a numpy.dtype or Python type to cast entire pandas object to
+        the same type. Alternatively, use {col: dtype, ...}, where col is a
+        column label and dtype is a numpy.dtype or Python type to cast one
+        or more of the DataFrame's columns to column-specific types.
+    copy : bool, default True
+        Return a copy when ``copy=True`` (be very careful setting
+        ``copy=False`` as changes to values then may propagate to other
+        pandas objects).
+    errors : {'raise', 'ignore'}, default 'raise'
+        Control raising of exceptions on invalid data for provided dtype.
+
+        - ``raise`` : allow exceptions to be raised
+        - ``ignore`` : suppress exceptions. On error return original object.
+
+    Returns
+    -------
+    casted : same type as caller
+
+    See Also
+    --------
+    to_datetime : Convert argument to datetime.
+    to_timedelta : Convert argument to timedelta.
+    to_numeric : Convert argument to a numeric type.
+    numpy.ndarray.astype : Cast a numpy array to a specified type.
+
+    Examples
+    --------
+    Create a DataFrame:
+
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame(pd.DataFrame({'col1': [1, 2], 'col2': [3, 4]}))
+    >>> df.dtypes
+    col1    int64
+    col2    int64
+    dtype: object
+
+    Cast all columns to int32:
+
+    >>> df.astype('int32').dtypes
+    col1    int32
+    col2    int32
+    dtype: object
+
+    Cast col1 to int32 using a dictionary:
+
+    >>> df.astype({'col1': 'int32'}).dtypes
+    col1    int32
+    col2    int64
+    dtype: object
+
+    Create a series:
+
+    >>> ser = md.Series(pd.Series([1, 2], dtype='int32'))
+    >>> ser.execute()
+    0    1
+    1    2
+    dtype: int32
+    >>> ser.astype('int64').execute()
+    0    1
+    1    2
+    dtype: int64
+
+    Convert to categorical type:
+
+    >>> ser.astype('category').execute()
+    0    1
+    1    2
+    dtype: category
+    Categories (2, int64): [1, 2]
+
+    Convert to ordered categorical type with custom ordering:
+
+    >>> cat_dtype = pd.api.types.CategoricalDtype(
+    ...     categories=[2, 1], ordered=True)
+    >>> ser.astype(cat_dtype).execute()
+    0    1
+    1    2
+    dtype: category
+    Categories (2, int64): [2 < 1]
+
+    Note that using ``copy=False`` and changing data on a new
+    pandas object may propagate changes:
+
+    >>> s1 = md.Series(pd.Series([1, 2]))
+    >>> s2 = s1.astype('int64', copy=False)
+    >>> s1.execute()  # note that s1[0] has changed too
+    0     1
+    1     2
+    dtype: int64
+    """
+    dtype = make_dtypes(dtype, make_series=False)
+    if isinstance(dtype, dict):
+        keys = list(dtype.keys())
+        if isinstance(df, SERIES_TYPE):
+            if len(keys) != 1 or keys[0] != df.name:
+                raise KeyError(
+                    "Only the Series name can be used for the key in Series dtype mappings."
+                )
+            else:
+                dtype = list(dtype.values())[0]
+        else:
+            for k in keys:
+                columns = df.columns_value.to_pandas()
+                if k not in columns:
+                    raise KeyError(
+                        "Only a column name can be used for the key in a dtype mappings argument."
+                    )
+    op = DataFrameAstype(dtype_values=dtype, errors=errors)
+    r = op(df)
+    if not copy:
+        df.data = r.data
+        return df
+    else:
+        return r
+
+
+def index_astype(ix, dtype, copy=True):
+    """
+    Create an Index with values cast to dtypes.
+
+    The class of a new Index is determined by dtype. When conversion is
+    impossible, a ValueError exception is raised.
+
+    Parameters
+    ----------
+    dtype : numpy dtype or pandas type
+        Note that any signed integer `dtype` is treated as ``'int64'``,
+        and any unsigned integer `dtype` is treated as ``'uint64'``,
+        regardless of the size.
+    copy : bool, default True
+        By default, astype always returns a newly allocated object.
+        If copy is set to False and internal requirements on dtype are
+        satisfied, the original data is used to create a new Index
+        or the original Index is returned.
+
+    Returns
+    -------
+    Index
+        Index with values cast to specified dtype.
+    """
+    return astype(ix, make_dtypes(dtype), copy=copy)

maxframe/dataframe/misc/case_when.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
+
+import numpy as np
+from pandas.core.dtypes.cast import find_common_type
+
+from ... import opcodes
+from ...core import TILEABLE_TYPE, EntityData
+from ...serialization.serializables import FieldTypes, ListField
+from ..core import SERIES_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import apply_if_callable
+
+
+class DataFrameCaseWhen(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.CASE_WHEN
+
+    conditions = ListField("conditions", FieldTypes.reference, default=None)
+    replacements = ListField("replacements", FieldTypes.reference, default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameCaseWhen", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        it = iter(inputs)
+        next(it)
+        op.conditions = [
+            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in op.conditions
+        ]
+        op.replacements = [
+            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in op.replacements
+        ]
+
+    def __call__(self, series):
+        replacement_dtypes = [
+            it.dtype if isinstance(it, SERIES_TYPE) else np.array(it).dtype
+            for it in self.replacements
+            if it is not None
+        ]
+        dtype = find_common_type([series.dtype] + replacement_dtypes)
+
+        condition_tileables = [
+            it for it in self.conditions if isinstance(it, TILEABLE_TYPE)
+        ]
+        replacement_tileables = [
+            it for it in self.replacements if isinstance(it, TILEABLE_TYPE)
+        ]
+        inputs = [series] + condition_tileables + replacement_tileables
+
+        params = series.params
+        params["dtype"] = dtype
+        return self.new_series(inputs, **params)
+
+
+def case_when(series, caselist):
+    """
+    Replace values where the conditions are True.
+
+    Parameters
+    ----------
+    caselist : A list of tuples of conditions and expected replacements
+        Takes the form:  ``(condition0, replacement0)``,
+        ``(condition1, replacement1)``, ... .
+        ``condition`` should be a 1-D boolean array-like object
+        or a callable. If ``condition`` is a callable,
+        it is computed on the Series
+        and should return a boolean Series or array.
+        The callable must not change the input Series
+        (though pandas doesn`t check it). ``replacement`` should be a
+        1-D array-like object, a scalar or a callable.
+        If ``replacement`` is a callable, it is computed on the Series
+        and should return a scalar or Series. The callable
+        must not change the input Series.
+
+    Returns
+    -------
+    Series
+
+    See Also
+    --------
+    Series.mask : Replace values where the condition is True.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> c = md.Series([6, 7, 8, 9], name='c')
+    >>> a = md.Series([0, 0, 1, 2])
+    >>> b = md.Series([0, 3, 4, 5])
+
+    >>> c.case_when(caselist=[(a.gt(0), a),  # condition, replacement
+    ...                       (b.gt(0), b)]).execute()
+    0    6
+    1    3
+    2    1
+    3    2
+    Name: c, dtype: int64
+    """
+    if not isinstance(caselist, list):
+        raise TypeError(
+            f"The caselist argument should be a list; instead got {type(caselist)}"
+        )
+
+    if not caselist:
+        raise ValueError(
+            "provide at least one boolean condition, "
+            "with a corresponding replacement."
+        )
+
+    for num, entry in enumerate(caselist):
+        if not isinstance(entry, tuple):
+            raise TypeError(
+                f"Argument {num} must be a tuple; instead got {type(entry)}."
+            )
+        if len(entry) != 2:
+            raise ValueError(
+                f"Argument {num} must have length 2; "
+                "a condition and replacement; "
+                f"instead got length {len(entry)}."
+            )
+    caselist = [
+        (
+            apply_if_callable(condition, series),
+            apply_if_callable(replacement, series),
+        )
+        for condition, replacement in caselist
+    ]
+    conditions = [case[0] for case in caselist]
+    replacements = [case[1] for case in caselist]
+    op = DataFrameCaseWhen(conditions=conditions, replacements=replacements)
+    return op(series)

maxframe/dataframe/misc/check_monotonic.py

@@ -0,0 +1,84 @@
+# 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 numpy as np
+
+from ... import opcodes
+from ...core import OutputType
+from ...serialization.serializables import BoolField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class DataFrameCheckMonotonic(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.CHECK_MONOTONIC
+
+    # 0 - increasing, 1 - decreasing
+    decreasing = BoolField("decreasing", default=None)
+    strict = BoolField("strict", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def __call__(self, df_obj):
+        self._output_types = [OutputType.scalar]
+        return self.new_tileable([df_obj], shape=(), dtype=np.dtype(bool))
+
+
+def check_monotonic(series_or_index, decreasing=False, strict=False):
+    """
+    Check if values in the object are monotonic increasing
+    or decreasing.
+
+    Parameters
+    ----------
+    decreasing : bool
+        If True, check if values are monotonic decreasing,
+        otherwise check if values are monotonic increasing
+    strict : bool
+        If True, values need to be unique to get a positive
+        result
+
+    Returns
+    -------
+    Scalar
+    """
+    op = DataFrameCheckMonotonic(decreasing=decreasing, strict=strict)
+    return op(series_or_index)
+
+
+def is_monotonic(series_or_index):
+    """
+    Return boolean scalar if values in the object are
+    monotonic_increasing.
+
+    Returns
+    -------
+    Scalar
+    """
+    return check_monotonic(series_or_index, decreasing=False, strict=False)
+
+
+is_monotonic_increasing = is_monotonic
+
+
+def is_monotonic_decreasing(series_or_index):
+    """
+    Return boolean scalar if values in the object are
+    monotonic_decreasing.
+
+    Returns
+    -------
+    Scalar
+    """
+    return check_monotonic(series_or_index, decreasing=True, strict=False)

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