maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/misc/qcut.py

@@ -0,0 +1,104 @@
+# 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
+import pandas as pd
+from pandas.api.types import is_integer
+
+from ...core import ENTITY_TYPE
+from ...tensor import tensor as astensor
+from ...tensor.statistics.percentile import percentile
+from ..core import DATAFRAME_TYPE, SERIES_TYPE
+from ..initializer import DataFrame, Series
+from .cut import cut
+
+
+def qcut(x, q, labels=None, retbins=False, precision=3, duplicate="raise"):
+    """
+    Quantile-based discretization function.
+
+    Discretize variable into equal-sized buckets based on rank or based
+    on sample quantiles. For example 1000 values for 10 quantiles would
+    produce a Categorical object indicating quantile membership for each data point.
+
+    Parameters
+    ----------
+    x : 1d tensor or Series
+    q : int or list-like of float
+        Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately
+        array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.
+    labels : array or False, default None
+        Used as labels for the resulting bins. Must be of the same length as
+        the resulting bins. If False, return only integer indicators of the
+        bins. If True, raises an error.
+    retbins : bool, optional
+        Whether to return the (bins, labels) or not. Can be useful if bins
+        is given as a scalar.
+    precision : int, optional
+        The precision at which to store and display the bins labels.
+    duplicates : {default 'raise', 'drop'}, optional
+        If bin edges are not unique, raise ValueError or drop non-uniques.
+
+    Returns
+    -------
+    out : Categorical or Series or tensor of integers if labels is False
+        The return type (Categorical or Series) depends on the input: a Series
+        of type category if input is a Series else Categorical. Bins are
+        represented as categories when categorical data is returned.
+    bins : tensor of floats
+        Returned only if `retbins` is True.
+
+    Notes
+    -----
+    Out of bounds values will be NA in the resulting Categorical object
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> md.qcut(range(5), 4).execute()
+    ... # doctest: +ELLIPSIS
+    [(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]]
+    Categories (4, interval[float64]): [(-0.001, 1.0] < (1.0, 2.0] ...
+
+    >>> md.qcut(range(5), 3, labels=["good", "medium", "bad"]).execute()
+    ... # doctest: +SKIP
+    [good, good, medium, bad, bad]
+    Categories (3, object): [good < medium < bad]
+
+    >>> md.qcut(range(5), 4, labels=False).execute()
+    array([0, 0, 1, 2, 3])
+    """
+    if is_integer(q):
+        q = np.linspace(0, 1, q + 1)
+
+    if isinstance(x, (DATAFRAME_TYPE, SERIES_TYPE, pd.DataFrame, pd.Series)):
+        x = DataFrame(x) if x.ndim == 2 else Series(x)
+        bins = x.quantile(q)
+    else:
+        x = astensor(x)
+        if isinstance(q, ENTITY_TYPE):
+            q = q * 100
+        else:
+            q = [iq * 100 for iq in q]
+        bins = percentile(x, q)
+
+    return cut(
+        x,
+        bins,
+        labels=labels,
+        retbins=retbins,
+        precision=precision,
+        include_lowest=True,
+        duplicates=duplicate,
+    )

maxframe/dataframe/misc/rechunk.py

@@ -0,0 +1,59 @@
+# 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
+from ...tensor.rechunk.rechunk import chunk_size_type
+from ...typing_ import TileableType
+from ..core import DATAFRAME_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class DataFrameRechunk(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.RECHUNK
+
+    chunk_size = AnyField("chunk_size")
+
+    def __call__(self, x):
+        if isinstance(x, DATAFRAME_TYPE):
+            return self.new_dataframe(
+                [x],
+                shape=x.shape,
+                dtypes=x.dtypes,
+                columns_value=x.columns_value,
+                index_value=x.index_value,
+            )
+        else:
+            self.output_types = x.op.output_types
+            f = (
+                self.new_series
+                if self.output_types[0] == OutputType.series
+                else self.new_index
+            )
+            return f(
+                [x],
+                shape=x.shape,
+                dtype=x.dtype,
+                index_value=x.index_value,
+                name=x.name,
+            )
+
+
+def rechunk(a: TileableType, chunk_size: chunk_size_type, reassign_worker=False):
+    op = DataFrameRechunk(
+        chunk_size=chunk_size,
+        reassign_worker=reassign_worker,
+    )
+    return op(a)

maxframe/dataframe/misc/repeat.py

@@ -0,0 +1,159 @@
+# 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.api.types import is_list_like
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, EntityData, get_output_types
+from ...serialization.serializables import AnyField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+
+class DataFrameRepeat(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.REPEAT
+
+    repeats = AnyField("repeats", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameRepeat", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if isinstance(op.repeats, ENTITY_TYPE):
+            op.repeats = inputs[1]
+
+    def __call__(self, obj, repeats):
+        self._output_types = get_output_types(obj)
+        test_index = obj.index_value.to_pandas()[:0]
+
+        params = obj.params
+        params["index_value"] = parse_index(test_index, obj, type(self), self.repeats)
+        params["shape"] = (np.nan,)
+
+        inputs = [obj]
+        if isinstance(repeats, ENTITY_TYPE):
+            inputs.append(repeats)
+        return self.new_tileable(inputs, **params)
+
+
+def _repeat(obj, repeats, axis=None):
+    from ...tensor.datasource import tensor
+
+    axis = validate_axis(axis or 0, obj)
+    if is_list_like(repeats):
+        repeats = tensor(repeats)
+    op = DataFrameRepeat(repeats=repeats, axis=axis)
+    return op(obj, repeats)
+
+
+def series_repeat(obj, repeats, axis=None):
+    """
+    Repeat elements of a Series.
+
+    Returns a new Series where each element of the current Series
+    is repeated consecutively a given number of times.
+
+    Parameters
+    ----------
+    repeats : int or array of ints
+        The number of repetitions for each element. This should be a
+        non-negative integer. Repeating 0 times will return an empty
+        Series.
+    axis : None
+        Must be ``None``. Has no effect but is accepted for compatibility
+        with numpy.
+
+    Returns
+    -------
+    Series
+        Newly created Series with repeated elements.
+
+    See Also
+    --------
+    Index.repeat : Equivalent function for Index.
+    numpy.repeat : Similar method for :class:`numpy.ndarray`.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series(['a', 'b', 'c'])
+    >>> s.execute()
+    0    a
+    1    b
+    2    c
+    dtype: object
+    >>> s.repeat(2).execute()
+    0    a
+    0    a
+    1    b
+    1    b
+    2    c
+    2    c
+    dtype: object
+    >>> s.repeat([1, 2, 3]).execute()
+    0    a
+    1    b
+    1    b
+    2    c
+    2    c
+    2    c
+    dtype: object
+    """
+    return _repeat(obj, repeats, axis=axis)
+
+
+def index_repeat(obj, repeats, axis=None):
+    """
+    Repeat elements of an Index.
+
+    Returns a new Index where each element of the current Index
+    is repeated consecutively a given number of times.
+
+    Parameters
+    ----------
+    repeats : int or array of ints
+        The number of repetitions for each element. This should be a
+        non-negative integer. Repeating 0 times will return an empty
+        Index.
+    axis : None
+        Must be ``None``. Has no effect but is accepted for compatibility
+        with numpy.
+
+    Returns
+    -------
+    repeated_index : Index
+        Newly created Index with repeated elements.
+
+    See Also
+    --------
+    Series.repeat : Equivalent function for Series.
+    numpy.repeat : Similar method for :class:`numpy.ndarray`.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> idx = md.Index(['a', 'b', 'c'])
+    >>> idx.execute()
+    Index(['a', 'b', 'c'], dtype='object')
+    >>> idx.repeat(2).execute()
+    Index(['a', 'a', 'b', 'b', 'c', 'c'], dtype='object')
+    >>> idx.repeat([1, 2, 3]).execute()
+    Index(['a', 'b', 'b', 'c', 'c', 'c'], dtype='object')
+    """
+    return _repeat(obj, repeats, axis=axis)

maxframe/dataframe/misc/select_dtypes.py

@@ -0,0 +1,104 @@
+# 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 build_empty_df
+
+
+def select_dtypes(df, include=None, exclude=None):
+    """
+    Return a subset of the DataFrame's columns based on the column dtypes.
+
+    Parameters
+    ----------
+    include, exclude : scalar or list-like
+        A selection of dtypes or strings to be included/excluded. At least
+        one of these parameters must be supplied.
+
+    Returns
+    -------
+    DataFrame
+        The subset of the frame including the dtypes in ``include`` and
+        excluding the dtypes in ``exclude``.
+
+    Raises
+    ------
+    ValueError
+        * If both of ``include`` and ``exclude`` are empty
+        * If ``include`` and ``exclude`` have overlapping elements
+        * If any kind of string dtype is passed in.
+
+    See Also
+    --------
+    DataFrame.dtypes: Return Series with the data type of each column.
+
+    Notes
+    -----
+    * To select all *numeric* types, use ``np.number`` or ``'number'``
+    * To select strings you must use the ``object`` dtype, but note that
+      this will return *all* object dtype columns
+    * See the `numpy dtype hierarchy
+      <https://numpy.org/doc/stable/reference/arrays.scalars.html>`__
+    * To select datetimes, use ``np.datetime64``, ``'datetime'`` or
+      ``'datetime64'``
+    * To select timedeltas, use ``np.timedelta64``, ``'timedelta'`` or
+      ``'timedelta64'``
+    * To select Pandas categorical dtypes, use ``'category'``
+    * To select Pandas datetimetz dtypes, use ``'datetimetz'`` (new in
+      0.20.0) or ``'datetime64[ns, tz]'``
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'a': [1, 2] * 3,
+    ...                    'b': [True, False] * 3,
+    ...                    'c': [1.0, 2.0] * 3})
+    >>> df.execute()
+            a      b  c
+    0       1   True  1.0
+    1       2  False  2.0
+    2       1   True  1.0
+    3       2  False  2.0
+    4       1   True  1.0
+    5       2  False  2.0
+
+    >>> df.select_dtypes(include='bool').execute()
+       b
+    0  True
+    1  False
+    2  True
+    3  False
+    4  True
+    5  False
+
+    >>> df.select_dtypes(include=['float64']).execute()
+       c
+    0  1.0
+    1  2.0
+    2  1.0
+    3  2.0
+    4  1.0
+    5  2.0
+
+    >>> df.select_dtypes(exclude=['int64']).execute()
+           b    c
+    0   True  1.0
+    1  False  2.0
+    2   True  1.0
+    3  False  2.0
+    4   True  1.0
+    5  False  2.0
+    """
+    test_df = build_empty_df(df.dtypes)
+    test_df = test_df.select_dtypes(include=include, exclude=exclude)
+    return df[test_df.dtypes.index.tolist()]

maxframe/dataframe/misc/shift.py

@@ -0,0 +1,259 @@
+# 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 pandas as pd
+
+from ... import opcodes
+from ...core import EntityData, OutputType
+from ...serialization.serializables import AnyField, Int8Field, Int64Field, KeyField
+from ...utils import no_default, pd_release_version
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_df, build_series, parse_index, validate_axis
+
+_need_consolidate = pd.__version__ in ("1.1.0", "1.3.0", "1.3.1")
+_enable_no_default = pd_release_version[:2] > (1, 1)
+_with_column_freq_bug = (1, 2, 0) <= pd_release_version < (1, 4, 3)
+
+
+class DataFrameShift(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SHIFT
+
+    _input = KeyField("input")
+    periods = Int64Field("periods", default=None)
+    freq = AnyField("freq", default=None)
+    axis = Int8Field("axis", default=None)
+    fill_value = AnyField("fill_value", default=None)
+
+    @property
+    def input(self):
+        return self._input
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameShift", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
+
+    def _call_dataframe(self, df):
+        test_df = build_df(df)
+        result_df = test_df.shift(
+            periods=self.periods,
+            freq=self.freq,
+            axis=self.axis,
+            fill_value=self.fill_value,
+        )
+
+        if self.freq is None:
+            # shift data
+            index_value = df.index_value
+            columns_value = df.columns_value
+        else:
+            # shift index
+            if self.axis == 0:
+                index_value = self._get_index_value(
+                    df.index_value, self.periods, self.freq
+                )
+                columns_value = df.columns_value
+            else:
+                columns_value = parse_index(result_df.dtypes.index, store_data=True)
+                index_value = df.index_value
+
+        return self.new_dataframe(
+            [df],
+            shape=df.shape,
+            dtypes=result_df.dtypes,
+            index_value=index_value,
+            columns_value=columns_value,
+        )
+
+    def _call_series(self, series):
+        test_series = build_series(series)
+        result_series = test_series.shift(
+            periods=self.periods,
+            freq=self.freq,
+            axis=self.axis,
+            fill_value=self.fill_value,
+        )
+
+        index_value = series.index_value
+        if self.freq is not None:
+            # shift index
+            index_value = self._get_index_value(index_value, self.periods, self.freq)
+
+        return self.new_series(
+            [series],
+            shape=series.shape,
+            index_value=index_value,
+            dtype=result_series.dtype,
+            name=series.name,
+        )
+
+    def __call__(self, df_or_series):
+        if df_or_series.op.output_types[0] == OutputType.dataframe:
+            self.output_types = [OutputType.dataframe]
+            return self._call_dataframe(df_or_series)
+        else:
+            assert df_or_series.op.output_types[0] == OutputType.series
+            self.output_types = [OutputType.series]
+            return self._call_series(df_or_series)
+
+    @staticmethod
+    def _get_index_value(input_index_value, periods, freq):
+        if (
+            not input_index_value.has_value()
+            and input_index_value.min_val is not None
+            and input_index_value.max_val is not None
+            and freq is not None
+            and input_index_value.is_monotonic_increasing_or_decreasing
+        ):
+            pd_index = pd.Index(
+                [input_index_value.min_val, input_index_value.max_val]
+            ).shift(periods=periods, freq=freq)
+            index_value = parse_index(pd_index)
+            index_value.value._min_val_close = input_index_value.min_val_close
+            index_value.value._max_val_close = input_index_value.max_val_close
+            return index_value
+        else:
+            pd_index = input_index_value.to_pandas()
+            return parse_index(pd_index, periods, freq)
+
+
+def shift(df_or_series, periods=1, freq=None, axis=0, fill_value=None):
+    """
+    Shift index by desired number of periods with an optional time `freq`.
+
+    When `freq` is not passed, shift the index without realigning the data.
+    If `freq` is passed (in this case, the index must be date or datetime,
+    or it will raise a `NotImplementedError`), the index will be
+    increased using the periods and the `freq`.
+
+    Parameters
+    ----------
+    periods : int
+        Number of periods to shift. Can be positive or negative.
+    freq : DateOffset, tseries.offsets, timedelta, or str, optional
+        Offset to use from the tseries module or time rule (e.g. 'EOM').
+        If `freq` is specified then the index values are shifted but the
+        data is not realigned. That is, use `freq` if you would like to
+        extend the index when shifting and preserve the original data.
+    axis : {0 or 'index', 1 or 'columns', None}, default None
+        Shift direction.
+    fill_value : object, optional
+        The scalar value to use for newly introduced missing values.
+        the default depends on the dtype of `self`.
+        For numeric data, ``np.nan`` is used.
+        For datetime, timedelta, or period data, etc. :attr:`NaT` is used.
+        For extension dtypes, ``self.dtype.na_value`` is used.
+
+    Returns
+    -------
+    DataFrame or Series
+        Copy of input object, shifted.
+
+    See Also
+    --------
+    Index.shift : Shift values of Index.
+    DatetimeIndex.shift : Shift values of DatetimeIndex.
+    PeriodIndex.shift : Shift values of PeriodIndex.
+    tshift : Shift the time index, using the index's frequency if
+        available.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+
+    >>> df = md.DataFrame({'Col1': [10, 20, 15, 30, 45],
+    ...                    'Col2': [13, 23, 18, 33, 48],
+    ...                    'Col3': [17, 27, 22, 37, 52]})
+
+    >>> df.shift(periods=3).execute()
+       Col1  Col2  Col3
+    0   NaN   NaN   NaN
+    1   NaN   NaN   NaN
+    2   NaN   NaN   NaN
+    3  10.0  13.0  17.0
+    4  20.0  23.0  27.0
+
+    >>> df.shift(periods=1, axis='columns').execute()
+       Col1  Col2  Col3
+    0   NaN  10.0  13.0
+    1   NaN  20.0  23.0
+    2   NaN  15.0  18.0
+    3   NaN  30.0  33.0
+    4   NaN  45.0  48.0
+
+    >>> df.shift(periods=3, fill_value=0).execute()
+       Col1  Col2  Col3
+    0     0     0     0
+    1     0     0     0
+    2     0     0     0
+    3    10    13    17
+    4    20    23    27
+    """
+    axis = validate_axis(axis, df_or_series)
+    if periods == 0:
+        return df_or_series.copy()
+    if fill_value is no_default:  # pragma: no cover
+        if not _enable_no_default or (
+            _with_column_freq_bug and axis == 1 and freq is not None
+        ):
+            # pandas shift shows different behavior for axis=1 when freq is specified,
+            # see https://github.com/pandas-dev/pandas/issues/47039 for details.
+            fill_value = None
+    op = DataFrameShift(periods=periods, freq=freq, axis=axis, fill_value=fill_value)
+    return op(df_or_series)
+
+
+def tshift(df_or_series, periods: int = 1, freq=None, axis=0):
+    """
+    Shift the time index, using the index's frequency if available.
+
+    Parameters
+    ----------
+    periods : int
+        Number of periods to move, can be positive or negative.
+    freq : DateOffset, timedelta, or str, default None
+        Increment to use from the tseries module
+        or time rule expressed as a string (e.g. 'EOM').
+    axis : {0 or ‘index’, 1 or ‘columns’, None}, default 0
+        Corresponds to the axis that contains the Index.
+
+    Returns
+    -------
+    shifted : Series/DataFrame
+
+    Notes
+    -----
+    If freq is not specified then tries to use the freq or inferred_freq
+    attributes of the index. If neither of those attributes exist, a
+    ValueError is thrown
+    """
+    axis = validate_axis(axis, df_or_series)
+    index = (
+        df_or_series.index_value.to_pandas()
+        if axis == 0
+        else df_or_series.columns_value.to_pandas()
+    )
+
+    if freq is None:
+        freq = getattr(index, "freq", None)
+
+    if freq is None:  # pragma: no cover
+        freq = getattr(index, "inferred_freq", None)
+
+    if freq is None:
+        raise ValueError("Freq was not given and was not set in the index")
+
+    return shift(df_or_series, periods=periods, freq=freq, axis=axis)

maxframe/dataframe/misc/tests/__init__.py

@@ -0,0 +1,13 @@
+# 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.