maxframe 2.0.0b2__cp311-cp311-win32.whl → 2.2.0__cp311-cp311-win32.whl

maxframe/dataframe/accessors/struct_/core.py

@@ -0,0 +1,43 @@
+# 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 DictField, StringField, TupleField
+from ....utils import no_default
+from ...operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class SeriesStructMethod(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_STRUCT_METHOD
+
+    method = StringField("method", default=None)
+    method_args = TupleField("method_args", default_factory=list)
+    method_kwargs = DictField("method_kwargs", default_factory=dict)
+
+    def __init__(self, output_types=None, **kw):
+        output_types = output_types or [OutputType.series]
+        kw["_output_types"] = kw.get("_output_types") or output_types
+        super().__init__(**kw)
+
+    def __call__(self, inp, dtype=None, name=no_default):
+        dtype = dtype if dtype is not None else inp.dtype
+        name = inp.name if name is no_default else name
+        return self.new_series(
+            [inp],
+            shape=inp.shape,
+            dtype=dtype,
+            index_value=inp.index_value,
+            name=name,
+        )

maxframe/dataframe/accessors/struct_/dtypes.py

@@ -0,0 +1,53 @@
+# 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 ....lib.dtypes_extension import ArrowDtype
+
+
+def struct_dtypes(series):
+    """
+    Return the dtype object of each child field of the struct.
+
+    Returns
+    -------
+    pandas.Series
+        The data type of each child field.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> import pandas as pd
+    >>> import pyarrow as pa
+    >>> s = md.Series(
+    ...     [
+    ...         {"version": 1, "project": "pandas"},
+    ...         {"version": 2, "project": "pandas"},
+    ...         {"version": 1, "project": "numpy"},
+    ...     ],
+    ...     dtype=pd.ArrowDtype(pa.struct(
+    ...         [("version", pa.int64()), ("project", pa.string())]
+    ...     ))
+    ... )
+    >>> s.struct.dtypes.execute()
+    version     int64[pyarrow]
+    project    string[pyarrow]
+    dtype: object
+    """
+    pa_type = series.dtype.pyarrow_dtype
+    fields = [pa_type[idx] for idx in range(pa_type.num_fields)]
+    dtypes_list = [ArrowDtype(ft.type) for ft in fields]
+    dt_name = [ft.name for ft in fields]
+    return pd.Series(dtypes_list, index=dt_name)

maxframe/dataframe/accessors/struct_/field.py

@@ -0,0 +1,123 @@
+# 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 ....lib.dtypes_extension import ArrowDtype
+from .core import SeriesStructMethod
+
+
+def struct_field(series, name_or_index):
+    """
+    Extract a child field of a struct as a Series.
+
+    Parameters
+    ----------
+    name_or_index : str | bytes | int | expression | list
+        Name or index of the child field to extract.
+
+        For list-like inputs, this will index into a nested
+        struct.
+
+    Returns
+    -------
+    pandas.Series
+        The data corresponding to the selected child field.
+
+    See Also
+    --------
+    Series.struct.explode : Return all child fields as a DataFrame.
+
+    Notes
+    -----
+    The name of the resulting Series will be set using the following
+    rules:
+
+    - For string, bytes, or integer `name_or_index` (or a list of these, for
+      a nested selection), the Series name is set to the selected
+      field's name.
+    - For a :class:`pyarrow.compute.Expression`, this is set to
+      the string form of the expression.
+    - For list-like `name_or_index`, the name will be set to the
+      name of the final field selected.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> import pandas as pd
+    >>> import pyarrow as pa
+    >>> s = md.Series(
+    ...     [
+    ...         {"version": 1, "project": "pandas"},
+    ...         {"version": 2, "project": "pandas"},
+    ...         {"version": 1, "project": "numpy"},
+    ...     ],
+    ...     dtype=pd.ArrowDtype(pa.struct(
+    ...         [("version", pa.int64()), ("project", pa.string())]
+    ...     ))
+    ... )
+
+    Extract by field name.
+
+    >>> s.struct.field("project").execute()
+    0    pandas
+    1    pandas
+    2     numpy
+    Name: project, dtype: string[pyarrow]
+
+    Extract by field index.
+
+    >>> s.struct.field(0).execute()
+    0    1
+    1    2
+    2    1
+    Name: version, dtype: int64[pyarrow]
+
+    For nested struct types, you can pass a list of values to index
+    multiple levels:
+
+    >>> version_type = pa.struct([
+    ...     ("major", pa.int64()),
+    ...     ("minor", pa.int64()),
+    ... ])
+    >>> s = 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())]
+    ...     ))
+    ... )
+    >>> s.struct.field(["version", "minor"]).execute()
+    0     5
+    1     1
+    2    26
+    Name: minor, dtype: int64[pyarrow]
+    >>> s.struct.field([0, 0]).execute()
+    0    1
+    1    2
+    2    1
+    Name: major, dtype: int64[pyarrow]
+    """
+    op = SeriesStructMethod(
+        method="field",
+        method_kwargs={"name_or_index": name_or_index},
+    )
+    names = name_or_index if isinstance(name_or_index, list) else [name_or_index]
+    arrow_type = series.dtype.pyarrow_dtype
+    arrow_name = None
+    for n in names:
+        arrow_name = arrow_type[n].name
+        arrow_type = arrow_type[n].type
+    return op(series, dtype=ArrowDtype(arrow_type), name=arrow_name)

maxframe/dataframe/accessors/struct_/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.

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
@@ -58,6 +59,7 @@ 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 +222,7 @@ def _install():
         DataFrameDegrees,
         DataFrameCeil,
         DataFrameFloor,
-        DataFrameAround,
+        DataFrameRound,
         DataFrameExp,
         DataFrameExp2,
         DataFrameExpm1,
@@ -255,7 +257,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 +313,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 +328,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