maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/window/__init__.py

@@ -0,0 +1,29 @@
+# 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.
+
+
+def _install():
+    from ..core import DATAFRAME_TYPE, SERIES_TYPE
+    from .ewm import ewm
+    from .expanding import expanding
+    from .rolling import rolling
+
+    for t in DATAFRAME_TYPE + SERIES_TYPE:
+        t.rolling = rolling
+        t.expanding = expanding
+        t.ewm = ewm
+
+
+_install()
+del _install

maxframe/dataframe/window/aggregation.py

@@ -0,0 +1,100 @@
+# 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 collections import OrderedDict
+from collections.abc import Iterable
+
+import numpy as np
+import pandas as pd
+
+from ...serialization.serializables import AnyField, BoolField, Int32Field, Int64Field
+from ..core import DATAFRAME_TYPE, ENTITY_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_df, build_empty_series, parse_index
+
+
+class BaseDataFrameExpandingAgg(DataFrameOperator, DataFrameOperatorMixin):
+    min_periods = Int64Field("min_periods", default=None)
+    axis = Int32Field("axis", default=0)
+    func = AnyField("func", default=None)
+
+    # always treat count as valid. this behavior is cancelled in pandas 1.0
+    count_always_valid = BoolField("count_always_valid", default=None)
+    # True if function name is treated as new index
+    append_index = BoolField("append_index", default=None)
+
+    def __call__(self, expanding):
+        inp = expanding.input
+        raw_func = self.func
+        self._normalize_funcs()
+
+        if isinstance(inp, DATAFRAME_TYPE):
+            empty_df = build_df(inp)
+            for c, t in empty_df.dtypes.items():
+                if t == np.dtype("O"):
+                    empty_df[c] = "O"
+
+            test_df = expanding(empty_df).agg(raw_func)
+            if self.axis == 0:
+                index_value = inp.index_value
+            else:
+                index_value = parse_index(
+                    test_df.index, expanding.params, inp, store_data=False
+                )
+            self.append_index = test_df.columns.nlevels != empty_df.columns.nlevels
+            return self.new_dataframe(
+                [inp],
+                shape=(inp.shape[0], test_df.shape[1]),
+                dtypes=test_df.dtypes,
+                index_value=index_value,
+                columns_value=parse_index(test_df.columns, store_data=True),
+            )
+        else:
+            pd_index = inp.index_value.to_pandas()
+            empty_series = build_empty_series(
+                inp.dtype, index=pd_index[:0], name=inp.name
+            )
+            test_obj = expanding(empty_series).agg(raw_func)
+            if isinstance(test_obj, pd.DataFrame):
+                return self.new_dataframe(
+                    [inp],
+                    shape=(inp.shape[0], test_obj.shape[1]),
+                    dtypes=test_obj.dtypes,
+                    index_value=inp.index_value,
+                    columns_value=parse_index(test_obj.dtypes.index, store_data=True),
+                )
+            else:
+                return self.new_series(
+                    [inp],
+                    shape=inp.shape,
+                    dtype=test_obj.dtype,
+                    index_value=inp.index_value,
+                    name=test_obj.name,
+                )
+
+    def _normalize_funcs(self):
+        if isinstance(self.func, dict):
+            new_func = OrderedDict()
+            for k, v in self.func.items():
+                if isinstance(v, str) or callable(v):
+                    new_func[k] = [v]
+                else:
+                    new_func[k] = v
+            self.func = new_func
+        elif (
+            isinstance(self.func, Iterable)
+            and not isinstance(self.func, ENTITY_TYPE)
+            and not isinstance(self.func, str)
+        ):
+            self.func = list(self.func)

maxframe/dataframe/window/core.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.
+
+from ...serialization.serializables import FieldTypes, KeyField, ListField, Serializable
+
+
+class Window(Serializable):
+    _mf_specific_fields = ["order_cols", "ascending"]
+
+    input = KeyField("input", default=None)
+    order_cols = ListField("order_cols", default=None)
+    ascending = ListField("ascending", FieldTypes.bool, default=None)
+
+    def __init__(self, *, order_cols=None, ascending=True, **kwargs):
+        if order_cols and not isinstance(order_cols, list):
+            order_cols = [order_cols]
+        if not isinstance(ascending, list):
+            ascending = [ascending]
+        elif order_cols and len(order_cols) != len(ascending):
+            raise ValueError("order_cols and ascending must have same length")
+        super().__init__(order_cols=order_cols, ascending=ascending, **kwargs)
+
+    @property
+    def params(self):
+        raise NotImplementedError
+
+    def _repr(self, params):
+        kvs = [f"{k}={v}" for k, v in params.items() if v is not None]
+        return "{} [{}]".format(self._repr_name(), ",".join(kvs))
+
+    def _repr_name(self):
+        return type(self).__name__
+
+    def __repr__(self):
+        return self._repr(self.params)
+
+    def __getitem__(self, item):
+        columns = self.input.dtypes.index
+        if isinstance(item, (list, tuple)):
+            item = list(item)
+            for col in item:
+                if col not in columns:
+                    raise KeyError(f"Column not found: {col}")
+        else:
+            if item not in columns:
+                raise KeyError(f"Column not found: {item}")
+
+        return type(self)(input=self.input[item], **self.params)
+
+    def __getattr__(self, item):
+        try:
+            return super().__getattribute__(item)
+        except AttributeError:
+            if self.input.ndim == 2 and item in self.input.dtypes:
+                return self[item]
+            else:
+                raise
+
+    def __dir__(self):
+        result = list(super().__dir__())
+        if self.input.ndim == 1:
+            return result
+        else:
+            return sorted(
+                result
+                + [
+                    k
+                    for k in self.input.dtypes.index
+                    if isinstance(k, str) and k.isidentifier()
+                ]
+            )

maxframe/dataframe/window/ewm.py

@@ -0,0 +1,247 @@
+# 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 math
+from collections import OrderedDict
+
+from ... import opcodes
+from ...serialization.serializables import (
+    BoolField,
+    Float64Field,
+    Int32Field,
+    Int64Field,
+    StringField,
+)
+from ...utils import pd_release_version
+from ..utils import validate_axis
+from .aggregation import BaseDataFrameExpandingAgg
+from .core import Window
+
+_default_min_period_1 = pd_release_version >= (1, 1, 0)
+_pd_1_3_repr = pd_release_version >= (1, 3, 0)
+_window_has_method = pd_release_version >= (1, 4, 0)
+
+
+class DataFrameEwmAgg(BaseDataFrameExpandingAgg):
+    _op_type_ = opcodes.EWM_AGG
+
+    alpha = Float64Field("alpha")
+    adjust = BoolField("adjust")
+    alpha_ignore_na = BoolField("alpha_ignore_na")
+
+    validate_columns = BoolField("_validate_columns")
+
+
+class EWM(Window):
+    alpha = Float64Field("alpha", default=None)
+    min_periods = Int64Field("min_periods", default=None)
+    adjust = BoolField("adjust", default=None)
+    ignore_na = BoolField("ignore_na", default=None)
+    axis = Int32Field("axis", default=None)
+    method = StringField("method", default="single")
+
+    @property
+    def params(self):
+        p = OrderedDict()
+
+        if not _window_has_method:  # pragma: no cover
+            args = ["alpha", "min_periods", "adjust", "ignore_na", "axis"]
+        else:
+            args = ["alpha", "min_periods", "adjust", "ignore_na", "axis", "method"]
+
+        for k in args:
+            p[k] = getattr(self, k)
+        return p
+
+    def __call__(self, df):
+        return df.ewm(**self.params)
+
+    def _repr(self, params):
+        com = 1.0 / params.pop("alpha") - 1
+        params["com"] = int(com) if _pd_1_3_repr and com == math.floor(com) else com
+        try:
+            params.move_to_end("com", last=False)
+        except AttributeError:  # pragma: no cover
+            pass
+        return super()._repr(params)
+
+    def _repr_name(self):
+        try:
+            from pandas.core.window import ExponentialMovingWindow  # noqa: F401
+
+            return "ExponentialMovingWindow"
+        except ImportError:  # pragma: no cover
+            return "EWM"
+
+    def aggregate(self, func):
+        params = self.params
+        params["alpha_ignore_na"] = params.pop("ignore_na", False)
+        params["validate_columns"] = False
+        op = DataFrameEwmAgg(func=func, **params)
+        return op(self)
+
+    agg = aggregate
+
+    def mean(self):
+        return self.aggregate("mean")
+
+    def var(self):
+        return self.aggregate("var")
+
+    def std(self):
+        return self.aggregate("std")
+
+
+def ewm(
+    obj,
+    com=None,
+    span=None,
+    halflife=None,
+    alpha=None,
+    min_periods=0,
+    adjust=True,
+    ignore_na=False,
+    axis=0,
+):
+    r"""
+    Provide exponential weighted functions.
+
+    Parameters
+    ----------
+    com : float, optional
+        Specify decay in terms of center of mass,
+        :math:`\alpha = 1 / (1 + com),\text{ for } com \geq 0`.
+    span : float, optional
+        Specify decay in terms of span,
+        :math:`\alpha = 2 / (span + 1),\text{ for } span \geq 1`.
+    halflife : float, optional
+        Specify decay in terms of half-life,
+        :math:`\alpha = 1 - exp(log(0.5) / halflife),\text{for} halflife > 0`.
+    alpha : float, optional
+        Specify smoothing factor :math:`\alpha` directly,
+        :math:`0 < \alpha \leq 1`.
+    min_periods : int, default 0
+        Minimum number of observations in window required to have a value
+        (otherwise result is NA).
+    adjust : bool, default True
+        Divide by decaying adjustment factor in beginning periods to account
+        for imbalance in relative weightings
+        (viewing EWMA as a moving average).
+    ignore_na : bool, default False
+        Ignore missing values when calculating weights;
+        specify True to reproduce pre-0.15.0 behavior.
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        The axis to use. The value 0 identifies the rows, and 1
+        identifies the columns.
+
+    Returns
+    -------
+    DataFrame
+        A Window sub-classed for the particular operation.
+
+    See Also
+    --------
+    rolling : Provides rolling window calculations.
+    expanding : Provides expanding transformations.
+
+    Notes
+    -----
+    Exactly one of center of mass, span, half-life, and alpha must be provided.
+
+    Allowed values and relationship between the parameters are specified in the
+    parameter descriptions above; see the link at the end of this section for
+    a detailed explanation.
+
+    When adjust is True (default), weighted averages are calculated using
+    weights (1-alpha)**(n-1), (1-alpha)**(n-2), ..., 1-alpha, 1.
+
+    When adjust is False, weighted averages are calculated recursively as:
+
+       weighted_average[0] = arg[0];
+       weighted_average[i] = (1-alpha)*weighted_average[i-1] + alpha*arg[i].
+
+    When ignore_na is False (default), weights are based on absolute positions.
+    For example, the weights of x and y used in calculating the final weighted
+    average of [x, None, y] are (1-alpha)**2 and 1 (if adjust is True), and
+    (1-alpha)**2 and alpha (if adjust is False).
+
+    When ignore_na is True (reproducing pre-0.15.0 behavior), weights are based
+    on relative positions. For example, the weights of x and y used in
+    calculating the final weighted average of [x, None, y] are 1-alpha and 1
+    (if adjust is True), and 1-alpha and alpha (if adjust is False).
+
+    More details can be found at
+    https://pandas.pydata.org/pandas-docs/stable/user_guide/computation.html#exponentially-weighted-windows
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'B': [0, 1, 2, np.nan, 4]})
+    >>> df.execute()
+         B
+    0  0.0
+    1  1.0
+    2  2.0
+    3  NaN
+    4  4.0
+    >>> df.ewm(com=0.5).mean().execute()
+              B
+    0  0.000000
+    1  0.750000
+    2  1.615385
+    3  1.615385
+    4  3.670213
+    """
+    axis = validate_axis(axis, obj)
+
+    decay_count = 0
+    for arg in (com, span, halflife, alpha):
+        if arg is not None:
+            decay_count += 1
+
+    if decay_count == 0:
+        raise ValueError("Must pass one of comass, span, halflife, or alpha")
+    if decay_count > 1:
+        raise ValueError("comass, span, halflife, and alpha are mutually exclusive")
+
+    if com is not None:
+        if com < 0:
+            raise ValueError("comass must satisfy: comass >= 0")
+        alpha = 1.0 / (1 + com)
+    elif span is not None:
+        if span < 1:
+            raise ValueError("span must satisfy: span >= 1")
+        alpha = 2.0 / (1 + span)
+    elif halflife is not None:
+        if halflife <= 0:
+            raise ValueError("halflife must satisfy: halflife > 0")
+        alpha = 1.0 - math.exp(math.log(0.5) / halflife)
+    if alpha <= 0 or alpha > 1:
+        raise ValueError("alpha must satisfy: 0 < alpha <= 1")
+
+    if alpha == 1:
+        return obj.expanding(min_periods=min_periods)
+
+    if _default_min_period_1:
+        min_periods = min_periods or 1
+
+    return EWM(
+        input=obj,
+        alpha=alpha,
+        min_periods=min_periods,
+        adjust=adjust,
+        ignore_na=ignore_na,
+        axis=axis,
+    )

maxframe/dataframe/window/expanding.py

@@ -0,0 +1,151 @@
+# 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 collections import OrderedDict
+
+from ... import opcodes
+from ...serialization.serializables import BoolField, Int64Field
+from .aggregation import BaseDataFrameExpandingAgg
+from .core import Window
+
+
+class DataFrameExpandingAgg(BaseDataFrameExpandingAgg):
+    _op_type_ = opcodes.EXPANDING_AGG
+
+    def __init__(self, *args, **kw):
+        # suspend MF-specific args by now
+        for key in Expanding._mf_specific_fields:
+            kw.pop(key, None)
+        super().__init__(*args, **kw)
+
+
+class Expanding(Window):
+    _mf_specific_fields = Window._mf_specific_fields + ["shift", "reverse_range"]
+
+    min_periods = Int64Field("min_periods")
+    # MF specific argument for position shift of window
+    shift = Int64Field("shift", default=None)
+    # MF specific argument for reversed window (sort of "narrowing")
+    reverse_range = BoolField("reverse_range", default=False)
+
+    def __call__(self, df):
+        try:
+            return df.expanding(**self.params)
+        except TypeError:
+            params = (self.params or dict()).copy()
+            for key in self._mf_specific_fields:
+                params.pop(key, None)
+            return df.expanding(**params)
+
+    @property
+    def params(self):
+        p = OrderedDict()
+
+        args = [
+            "min_periods",
+            "shift",
+            "reverse_range",
+            "order_cols",
+            "ascending",
+        ]
+
+        for k in args:
+            p[k] = getattr(self, k)
+        return p
+
+    def aggregate(self, func, **kwargs):
+        count_always_valid = kwargs.pop("_count_always_valid", False)
+
+        op = DataFrameExpandingAgg(
+            func=func, count_always_valid=count_always_valid, **self.params
+        )
+        return op(self)
+
+    agg = aggregate
+
+    def sum(self):
+        return self.aggregate("sum")
+
+    def prod(self):
+        return self.aggregate("prod")
+
+    def count(self):
+        return self.aggregate("count")
+
+    def min(self):
+        return self.aggregate("min")
+
+    def max(self):
+        return self.aggregate("max")
+
+    def mean(self):
+        return self.aggregate("mean")
+
+    def var(self, **kwargs):
+        return self.aggregate("var", **kwargs)
+
+    def std(self, **kwargs):
+        return self.aggregate("std", **kwargs)
+
+
+def expanding(obj, min_periods=1, shift=0, reverse_range=False):
+    """
+    Provide expanding transformations.
+
+    Parameters
+    ----------
+    min_periods : int, default 1
+    Minimum number of observations in window required to have a value
+    (otherwise result is NA).
+    center : bool, default False
+    Set the labels at the center of the window.
+    axis : int or str, default 0
+
+    Returns
+    -------
+    a Window sub-classed for the particular operation
+
+    See Also
+    --------
+    rolling : Provides rolling window calculations.
+    ewm : Provides exponential weighted functions.
+
+    Notes
+    -----
+    By default, the result is set to the right edge of the window. This can be
+    changed to the center of the window by setting ``center=True``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'B': [0, 1, 2, np.nan, 4]})
+    >>> df.execute()
+         B
+    0  0.0
+    1  1.0
+    2  2.0
+    3  NaN
+    4  4.0
+    >>> df.expanding(2).sum().execute()
+         B
+    0  NaN
+    1  1.0
+    2  3.0
+    3  3.0
+    4  7.0
+    """
+    return Expanding(
+        input=obj, min_periods=min_periods, shift=shift, reverse_range=reverse_range
+    )