maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/dataframe/misc/astype.py

@@ -0,0 +1,236 @@
+# Copyright 1999-2024 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 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
+    """
+    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, dtype, copy=copy)

maxframe/dataframe/misc/case_when.py

@@ -0,0 +1,141 @@
+# Copyright 1999-2024 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 pandas.core.dtypes.cast import find_common_type
+
+from ... import opcodes
+from ...core import TILEABLE_TYPE
+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)
+
+    def _set_inputs(self, inputs):
+        super()._set_inputs(inputs)
+        it = iter(inputs)
+        next(it)
+        self.conditions = [
+            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in self.conditions
+        ]
+        self.replacements = [
+            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in self.replacements
+        ]
+
+    def __call__(self, series):
+        replacement_dtypes = [
+            it.dtype if isinstance(it, SERIES_TYPE) else np.array(it).dtype
+            for it in self.replacements
+        ]
+        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)])
+    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-2024 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)