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

maxframe/dataframe/accessors/struct_/tests/test_struct_accessor.py

@@ -0,0 +1,91 @@
+# 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
+import pyarrow as pa
+import pytest
+
+from ..... import dataframe as md
+from .....utils import ARROW_DTYPE_NOT_SUPPORTED
+from ..core import SeriesStructMethod
+
+pytestmark = pytest.mark.skipif(
+    ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
+)
+
+
+@pytest.fixture
+def series():
+    version_type = pa.struct(
+        [
+            ("major", pa.int64()),
+            ("minor", pa.int64()),
+        ]
+    )
+    return md.Series(
+        [
+            {"version": {"major": 1, "minor": 5}, "project": "pandas"},
+            {"version": {"major": 2, "minor": 1}, "project": "pandas"},
+            {"version": {"major": 1, "minor": 26}, "project": "numpy"},
+        ],
+        dtype=pd.ArrowDtype(
+            pa.struct([("version", version_type), ("project", pa.string())])
+        ),
+    )
+
+
+def test_dtypes(series):
+    pd.testing.assert_series_equal(
+        series.struct.dtypes,
+        pd.Series(
+            [
+                pd.ArrowDtype(
+                    pa.struct([("major", pa.int64()), ("minor", pa.int64())])
+                ),
+                pd.ArrowDtype(pa.string()),
+            ],
+            index=["version", "project"],
+        ),
+    )
+
+
+def test_field(series):
+    version_type = pa.struct(
+        [
+            ("major", pa.int64()),
+            ("minor", pa.int64()),
+        ]
+    )
+
+    s1 = series.struct.field("version")
+    assert isinstance(s1, md.Series)
+    assert s1.name == "version"
+    assert s1.dtype == pd.ArrowDtype(version_type)
+    assert s1.shape == (3,)
+    assert s1.index_value == series.index_value
+    op = s1.op
+    assert isinstance(op, SeriesStructMethod)
+    assert op.method == "field"
+    assert op.method_kwargs["name_or_index"] == "version"
+
+    s2 = series.struct.field(["version", "major"])
+    assert isinstance(s1, md.Series)
+    assert s2.name == "major"
+    assert s2.dtype == pd.ArrowDtype(pa.int64())
+    assert s2.shape == (3,)
+    assert s2.index_value == series.index_value
+    op = s2.op
+    assert isinstance(op, SeriesStructMethod)
+    assert op.method == "field"
+    assert op.method_kwargs["name_or_index"] == ["version", "major"]

maxframe/dataframe/arithmetic/__init__.py

@@ -29,14 +29,15 @@ from .arcsin import DataFrameArcsin
 from .arcsinh import DataFrameArcsinh
 from .arctan import DataFrameArctan
 from .arctanh import DataFrameArctanh
-from .around import DataFrameAround, around
+from .between import between
 from .bitwise_and import DataFrameAnd, bitand, rbitand
-from .bitwise_or import DataFrameOr, bitor, rbitor
+from .bitwise_or import DataFrameOr, DataFrameTreeOr, bitor, rbitor
 from .bitwise_xor import DataFrameXor, bitxor, rbitxor
 from .ceil import DataFrameCeil
 from .cos import DataFrameCos
 from .cosh import DataFrameCosh
 from .degrees import DataFrameDegrees
+from .dot import DataFrameDot, dot, rdot
 from .equal import DataFrameEqual, eq
 from .exp import DataFrameExp
 from .exp2 import DataFrameExp2
@@ -52,12 +53,15 @@ from .less_equal import DataFrameLessEqual, le
 from .log import DataFrameLog
 from .log2 import DataFrameLog2
 from .log10 import DataFrameLog10
+from .maximum import DataFrameMaximum
+from .minimum import DataFrameMinimum
 from .mod import DataFrameMod, mod, rmod
 from .multiply import DataFrameMul, mul, rmul
 from .negative import DataFrameNegative, negative
 from .not_equal import DataFrameNotEqual, ne
 from .power import DataFramePower, power, rpower
 from .radians import DataFrameRadians
+from .round import DataFrameRound, round
 from .sin import DataFrameSin
 from .sinh import DataFrameSinh
 from .sqrt import DataFrameSqrt
@@ -220,7 +224,7 @@ def _install():
         DataFrameDegrees,
         DataFrameCeil,
         DataFrameFloor,
-        DataFrameAround,
+        DataFrameRound,
         DataFrameExp,
         DataFrameExp2,
         DataFrameExpm1,
@@ -248,6 +252,8 @@ def _install():
         DataFramePower,
         DataFrameSubtract,
         DataFrameTrueDiv,
+        DataFrameMaximum,
+        DataFrameMinimum,
     ]
     for ufunc_op in ufunc_ops:
         register_tensor_ufunc(ufunc_op)
@@ -255,7 +261,8 @@ def _install():
     for entity in DATAFRAME_TYPE + SERIES_TYPE:
         setattr(entity, "__abs__", abs_)
         setattr(entity, "abs", abs_)
-        _register_method(entity, "round", around)
+        _register_method(entity, "around", round)
+        _register_method(entity, "round", round)
         setattr(entity, "__invert__", invert)
 
         setattr(entity, "__add__", wrap_notimplemented_exception(add))
@@ -310,6 +317,10 @@ def _install():
         _register_bin_method(entity, "ge", ge)
         _register_bin_method(entity, "le", le)
 
+        setattr(entity, "__matmul__", dot)
+        setattr(entity, "__rmatmul__", rdot)
+        _register_method(entity, "dot", dot)
+
         setattr(entity, "__and__", wrap_notimplemented_exception(bitand))
         setattr(entity, "__rand__", wrap_notimplemented_exception(rbitand))
 
@@ -321,6 +332,9 @@ def _install():
 
         setattr(entity, "__neg__", wrap_notimplemented_exception(negative))
 
+    for entity in SERIES_TYPE:
+        setattr(entity, "between", between)
+
     for entity in INDEX_TYPE:
         setattr(entity, "__eq__", _wrap_eq())
 

maxframe/dataframe/arithmetic/between.py

@@ -0,0 +1,106 @@
+# 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 between(series, left, right, inclusive="both"):
+    """
+    Return boolean Series equivalent to left <= series <= right.
+    This function returns a boolean vector containing `True` wherever the
+    corresponding Series element is between the boundary values `left` and
+    `right`. NA values are treated as `False`.
+
+    Parameters
+    ----------
+    left : scalar or list-like
+        Left boundary.
+    right : scalar or list-like
+        Right boundary.
+    inclusive : {"both", "neither", "left", "right"}
+        Include boundaries. Whether to set each bound as closed or open.
+
+    Returns
+    -------
+    Series
+        Series representing whether each element is between left and
+        right (inclusive).
+
+    See Also
+    --------
+    Series.gt : Greater than of series and other.
+    Series.lt : Less than of series and other.
+
+    Notes
+    -----
+    This function is equivalent to ``(left <= ser) & (ser <= right)``
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([2, 0, 4, 8, np.nan])
+
+    Boundary values are included by default:
+
+    >>> s.between(1, 4).execute()
+    0     True
+    1    False
+    2     True
+    3    False
+    4    False
+    dtype: bool
+
+    With `inclusive` set to ``"neither"`` boundary values are excluded:
+
+    >>> s.between(1, 4, inclusive="neither").execute()
+    0     True
+    1    False
+    2    False
+    3    False
+    4    False
+    dtype: bool
+
+    `left` and `right` can be any scalar value:
+
+    >>> s = md.Series(['Alice', 'Bob', 'Carol', 'Eve'])
+    >>> s.between('Anna', 'Daniel').execute()
+    0    False
+    1     True
+    2     True
+    3    False
+    dtype: bool
+    """
+    if isinstance(inclusive, bool):  # pragma: no cover
+        # for pandas < 1.3.0
+        if inclusive:
+            inclusive = "both"
+        else:
+            inclusive = "neither"
+    if inclusive == "both":
+        lmask = series >= left
+        rmask = series <= right
+    elif inclusive == "left":
+        lmask = series >= left
+        rmask = series < right
+    elif inclusive == "right":
+        lmask = series > left
+        rmask = series <= right
+    elif inclusive == "neither":
+        lmask = series > left
+        rmask = series < right
+    else:
+        raise ValueError(
+            "Inclusive has to be either string of 'both',"
+            "'left', 'right', or 'neither'."
+        )
+
+    return lmask & rmask

maxframe/dataframe/arithmetic/dot.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.
+
+from typing import List
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import AnyField, KeyField
+from ...tensor import tensor as astensor
+from ...tensor.core import TENSOR_TYPE
+from ..core import DATAFRAME_TYPE, SERIES_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+
+class DataFrameDot(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DOT
+
+    lhs = KeyField("lhs")
+    rhs = AnyField("rhs")
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameDot", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.lhs, op.rhs = op._inputs[:2]
+
+    def __call__(self, lhs, rhs):
+        lhs = self._process_input(lhs)
+        rhs = self._process_input(rhs)
+        if not isinstance(rhs, (DATAFRAME_TYPE, SERIES_TYPE)):
+            rhs = astensor(rhs)
+            test_rhs = rhs
+        else:
+            test_rhs = rhs.to_tensor()
+
+        test_ret = lhs.to_tensor().dot(test_rhs)
+        if test_ret.ndim == 0:
+            if isinstance(lhs, SERIES_TYPE) and isinstance(rhs, TENSOR_TYPE):
+                # return tensor
+                return test_ret
+            return self.new_scalar([lhs, rhs], dtype=test_ret.dtype)
+        elif test_ret.ndim == 1:
+            if lhs.ndim == 1:
+                if hasattr(rhs, "columns_value"):
+                    index_value = rhs.columns_value
+                else:
+                    # tensor
+                    length = -1 if np.isnan(rhs.shape[1]) else rhs.shape[1]
+                    pd_index = pd.RangeIndex(length)
+                    index_value = parse_index(pd_index, store_data=True)
+            else:
+                assert rhs.ndim == 1
+                index_value = lhs.index_value
+            return self.new_series(
+                [lhs, rhs],
+                shape=test_ret.shape,
+                dtype=test_ret.dtype,
+                index_value=index_value,
+            )
+        else:
+            if isinstance(rhs, TENSOR_TYPE):
+                dtypes = pd.Series(
+                    np.repeat(test_ret.dtype, test_ret.shape[1]),
+                    index=pd.RangeIndex(test_ret.shape[1]),
+                )
+                columns_value = parse_index(dtypes.index, store_data=True)
+            else:
+                dtypes = pd.Series(
+                    np.repeat(test_ret.dtype, test_ret.shape[1]),
+                    index=rhs.columns_value.to_pandas(),
+                )
+                columns_value = rhs.columns_value
+            return self.new_dataframe(
+                [lhs, rhs],
+                shape=test_ret.shape,
+                index_value=lhs.index_value,
+                columns_value=columns_value,
+                dtypes=dtypes,
+            )
+
+
+def dot(df_or_series, other):
+    op = DataFrameDot(lhs=df_or_series, rhs=other)
+    return op(df_or_series, other)
+
+
+def rdot(df_or_series, other):
+    op = DataFrameDot(lhs=other, rhs=df_or_series)
+    return op(other, df_or_series)
+
+
+dot.__frame_doc__ = """
+Compute the matrix multiplication between the DataFrame and other.
+
+This method computes the matrix product between the DataFrame and the
+values of an other Series, DataFrame or a numpy array.
+
+It can also be called using ``self @ other`` in Python >= 3.5.
+
+Parameters
+----------
+other : Series, DataFrame or array-like
+    The other object to compute the matrix product with.
+
+Returns
+-------
+Series or DataFrame
+    If other is a Series, return the matrix product between self and
+    other as a Series. If other is a DataFrame or a numpy.array, return
+    the matrix product of self and other in a DataFrame of a np.array.
+
+See Also
+--------
+Series.dot: Similar method for Series.
+
+Notes
+-----
+The dimensions of DataFrame and other must be compatible in order to
+compute the matrix multiplication. In addition, the column names of
+DataFrame and the index of other must contain the same values, as they
+will be aligned prior to the multiplication.
+
+The dot method for Series computes the inner product, instead of the
+matrix product here.
+
+Examples
+--------
+Here we multiply a DataFrame with a Series.
+
+>>> import maxframe.tensor as mt
+>>> import maxframe.dataframe as md
+>>> df = md.DataFrame([[0, 1, -2, -1], [1, 1, 1, 1]])
+>>> s = md.Series([1, 1, 2, 1])
+>>> df.dot(s).execute()
+0    -4
+1     5
+dtype: int64
+
+Here we multiply a DataFrame with another DataFrame.
+
+>>> other = md.DataFrame([[0, 1], [1, 2], [-1, -1], [2, 0]])
+>>> df.dot(other).execute()
+    0   1
+0   1   4
+1   2   2
+
+Note that the dot method give the same result as @
+
+>>> (df @ other).execute()
+    0   1
+0   1   4
+1   2   2
+
+The dot method works also if other is an np.array.
+
+>>> arr = mt.array([[0, 1], [1, 2], [-1, -1], [2, 0]])
+>>> df.dot(arr).execute()
+    0   1
+0   1   4
+1   2   2
+
+Note how shuffling of the objects does not change the result.
+
+>>> s2 = s.reindex([1, 0, 2, 3])
+>>> df.dot(s2).execute()
+0    -4
+1     5
+dtype: int64
+"""
+dot.__series_doc__ = """
+Compute the dot product between the Series and the columns of other.
+
+This method computes the dot product between the Series and another
+one, or the Series and each columns of a DataFrame, or the Series and
+each columns of an array.
+
+It can also be called using `self @ other` in Python >= 3.5.
+
+Parameters
+----------
+other : Series, DataFrame or array-like
+    The other object to compute the dot product with its columns.
+
+Returns
+-------
+scalar, Series or numpy.ndarray
+    Return the dot product of the Series and other if other is a
+    Series, the Series of the dot product of Series and each rows of
+    other if other is a DataFrame or a numpy.ndarray between the Series
+    and each columns of the numpy array.
+
+See Also
+--------
+DataFrame.dot: Compute the matrix product with the DataFrame.
+Series.mul: Multiplication of series and other, element-wise.
+
+Notes
+-----
+The Series and other has to share the same index if other is a Series
+or a DataFrame.
+
+Examples
+--------
+>>> import maxframe.tensor as mt
+>>> import maxframe.dataframe as md
+>>> s = md.Series([0, 1, 2, 3])
+>>> other = md.Series([-1, 2, -3, 4])
+>>> s.dot(other).execute()
+8
+>>> (s @ other).execute()
+8
+>>> df = md.DataFrame([[0, 1], [-2, 3], [4, -5], [6, 7]])
+>>> s.dot(df).execute()
+0    24
+1    14
+dtype: int64
+>>> arr = mt.array([[0, 1], [-2, 3], [4, -5], [6, 7]])
+>>> s.dot(arr).execute()
+array([24, 14])
+"""

maxframe/dataframe/arithmetic/maximum.py

@@ -0,0 +1,33 @@
+# 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 ...utils import classproperty
+from .core import DataFrameBinopUfunc
+
+
+class DataFrameMaximum(DataFrameBinopUfunc):
+    _op_type_ = opcodes.MAXIMUM
+
+    @classproperty
+    def _operator(self):
+        return np.maximum
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorMaximum
+
+        return TensorMaximum

maxframe/dataframe/arithmetic/minimum.py

@@ -0,0 +1,33 @@
+# 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 ...utils import classproperty
+from .core import DataFrameBinopUfunc
+
+
+class DataFrameMinimum(DataFrameBinopUfunc):
+    _op_type_ = opcodes.MINIMUM
+
+    @classproperty
+    def _operator(self):
+        return np.minimum
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorMinimum
+
+        return TensorMinimum

maxframe/dataframe/arithmetic/{around.py → round.py}

@@ -18,9 +18,10 @@ from ...utils import classproperty
 from .core import DataFrameUnaryUfunc
 
 
-class DataFrameAround(DataFrameUnaryUfunc):
+class DataFrameRound(DataFrameUnaryUfunc):
     _op_type_ = opcodes.AROUND
-    _func_name = "around"
+    _func_name = "round"
+    _legacy_name = "DataFrameAround"  # since v2.3.0
 
     decimals = Int32Field("decimals", default=None)
 
@@ -34,17 +35,20 @@ class DataFrameAround(DataFrameUnaryUfunc):
         return TensorAround
 
 
-def around(df, decimals=0, *args, **kwargs):
+def round(df, decimals=0, *args, **kwargs):
     if len(args) > 0:
         raise TypeError(
             f"round() takes 0 positional arguments but {len(args)} was given"
         )
-    op = DataFrameAround(decimals=decimals, **kwargs)
+    op = DataFrameRound(decimals=decimals, **kwargs)
     return op(df)
 
 
-# FIXME Series input of decimals not supported yet
-around.__frame_doc__ = """
+# keep for import compatibility
+DataFrameAround = DataFrameRound
+
+
+round.__frame_doc__ = """
 Round a DataFrame to a variable number of decimal places.
 
 Parameters
@@ -108,7 +112,7 @@ places as value
 2   0.7   0.0
 3   0.2   0.0
 """
-around.__series_doc__ = """
+round.__series_doc__ = """
 Round each value in a Series to the given number of decimals.
 
 Parameters