maxframe 2.2.0__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

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

@@ -0,0 +1,369 @@
+# 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 functools
+
+import pandas as pd
+
+try:
+    from pandas.core.arraylike import OpsMixin as PdOpsMixin
+except ImportError:  # pragma: no cover
+    PdOpsMixin = None
+
+from .abs import DataFrameAbs, abs_
+from .add import DataFrameAdd, add, radd
+from .arccos import DataFrameArccos
+from .arccosh import DataFrameArccosh
+from .arcsin import DataFrameArcsin
+from .arcsinh import DataFrameArcsinh
+from .arctan import DataFrameArctan
+from .arctanh import DataFrameArctanh
+from .between import between
+from .bitwise_and import DataFrameAnd, bitand, rbitand
+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
+from .expm1 import DataFrameExpm1
+from .floor import DataFrameFloor
+from .floordiv import DataFrameFloorDiv, floordiv, rfloordiv
+from .greater import DataFrameGreater, gt
+from .greater_equal import DataFrameGreaterEqual, ge
+from .invert import DataFrameNot, invert
+from .is_ufuncs import DataFrameIsFinite, DataFrameIsInf, DataFrameIsNan
+from .less import DataFrameLess, lt
+from .less_equal import DataFrameLessEqual, le
+from .log import DataFrameLog
+from .log2 import DataFrameLog2
+from .log10 import DataFrameLog10
+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
+from .subtract import DataFrameSubtract, rsubtract, subtract
+from .tan import DataFrameTan
+from .tanh import DataFrameTanh
+from .truediv import DataFrameTrueDiv, rtruediv, truediv
+from .trunc import DataFrameTrunc
+
+
+def _wrap_eq():
+    @functools.wraps(eq)
+    def call(df, other, **kw):
+        from ..core import is_build_mode
+
+        if is_build_mode():
+            return df._equals(other)
+        return _wrap_comparison(eq)(df, other, **kw)
+
+    return call
+
+
+def _wrap_comparison(func):
+    @functools.wraps(func)
+    def call(df, other, **kw):
+        from ..core import DATAFRAME_TYPE
+        from ..utils import wrap_notimplemented_exception
+
+        if isinstance(df, DATAFRAME_TYPE) and isinstance(other, DATAFRAME_TYPE):
+            # index and columns should be identical
+            for index_type in ["index_value", "columns_value"]:
+                left, right = getattr(df, index_type), getattr(other, index_type)
+                if left.has_value() and right.has_value():
+                    # if df and other's index or columns has value
+                    index_eq = left.to_pandas().equals(right.to_pandas())
+                else:
+                    index_eq = left.key == right.key
+                if not index_eq:
+                    raise ValueError(
+                        "Can only compare identically-labeled DataFrame object"
+                    )
+        return wrap_notimplemented_exception(func)(df, other, **kw)
+
+    return call
+
+
+_reverse_magic_names = {
+    "eq": "eq",
+    "ne": "ne",
+    "lt": "ge",
+    "le": "gt",
+    "gt": "le",
+    "ge": "lt",
+}
+
+
+def _wrap_pandas_magics(cls, magic_name: str):
+    magic_func_name = f"__{magic_name}__"
+    magic_rfunc_name = _reverse_magic_names.get(magic_name, f"__r{magic_name}__")
+    try:
+        raw_method = getattr(cls, magic_func_name)
+    except AttributeError:
+        return
+
+    @functools.wraps(raw_method)
+    def wrapped(self, other):
+        from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
+
+        if not isinstance(other, (DATAFRAME_TYPE, SERIES_TYPE, INDEX_TYPE)):
+            return raw_method(self, other)
+
+        try:
+            val = getattr(other, magic_rfunc_name)(self)
+        except AttributeError:  # pragma: no cover
+            return raw_method(self, other)
+
+        if val is NotImplemented:  # pragma: no cover
+            return raw_method(self, other)
+        return val
+
+    setattr(cls, magic_func_name, wrapped)
+
+
+def _install():
+    from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
+    from ..ufunc.tensor import register_tensor_ufunc
+    from ..utils import wrap_notimplemented_exception
+
+    def _register_method(cls, name, func, wrapper=None):
+        from ..core import DATAFRAME_TYPE, SERIES_TYPE
+
+        if wrapper is None:
+
+            @functools.wraps(func)
+            def wrapper(df, *args, **kwargs):
+                return func(df, *args, **kwargs)
+
+        try:
+            if issubclass(cls, DATAFRAME_TYPE):
+                wrapper.__doc__ = func.__frame_doc__
+            elif issubclass(cls, SERIES_TYPE):
+                wrapper.__doc__ = func.__series_doc__
+            else:
+                wrapper = func
+        except AttributeError:
+            wrapper = func
+
+        wrapper.__name__ = func.__name__
+        setattr(cls, name, wrapper)
+
+    def _register_bin_method(cls, name, func):
+        def call_df_fill(df, other, axis="columns", level=None, fill_value=None):
+            return func(df, other, axis=axis, level=level, fill_value=fill_value)
+
+        def call_df_no_fill(df, other, axis="columns", level=None):
+            return func(df, other, axis=axis, level=level)
+
+        def call_series_fill(df, other, level=None, fill_value=None, axis=0):
+            return func(df, other, axis=axis, level=level, fill_value=fill_value)
+
+        def call_series_no_fill(df, other, level=None, axis=0):
+            return func(df, other, axis=axis, level=level)
+
+        if issubclass(cls, DATAFRAME_TYPE):
+            call = (
+                call_df_fill
+                if "fill_value" in func.__code__.co_varnames
+                else call_df_no_fill
+            )
+        elif issubclass(cls, SERIES_TYPE):
+            call = (
+                call_series_fill
+                if "fill_value" in func.__code__.co_varnames
+                else call_series_no_fill
+            )
+        else:
+            call = None
+        return _register_method(cls, name, func, wrapper=call)
+
+    # register maxframe tensor ufuncs
+    ufunc_ops = [
+        # unary
+        DataFrameAbs,
+        DataFrameLog,
+        DataFrameLog2,
+        DataFrameLog10,
+        DataFrameSin,
+        DataFrameCos,
+        DataFrameTan,
+        DataFrameSinh,
+        DataFrameCosh,
+        DataFrameTanh,
+        DataFrameArcsin,
+        DataFrameArccos,
+        DataFrameArctan,
+        DataFrameArcsinh,
+        DataFrameArccosh,
+        DataFrameArctanh,
+        DataFrameRadians,
+        DataFrameDegrees,
+        DataFrameCeil,
+        DataFrameFloor,
+        DataFrameRound,
+        DataFrameExp,
+        DataFrameExp2,
+        DataFrameExpm1,
+        DataFrameSqrt,
+        DataFrameNot,
+        DataFrameIsNan,
+        DataFrameIsInf,
+        DataFrameIsFinite,
+        DataFrameNegative,
+        DataFrameTrunc,
+        # binary
+        DataFrameAdd,
+        DataFrameEqual,
+        DataFrameFloorDiv,
+        DataFrameGreater,
+        DataFrameGreaterEqual,
+        DataFrameLess,
+        DataFrameLessEqual,
+        DataFrameAnd,
+        DataFrameOr,
+        DataFrameXor,
+        DataFrameMod,
+        DataFrameMul,
+        DataFrameNotEqual,
+        DataFramePower,
+        DataFrameSubtract,
+        DataFrameTrueDiv,
+    ]
+    for ufunc_op in ufunc_ops:
+        register_tensor_ufunc(ufunc_op)
+
+    for entity in DATAFRAME_TYPE + SERIES_TYPE:
+        setattr(entity, "__abs__", abs_)
+        setattr(entity, "abs", abs_)
+        _register_method(entity, "around", round)
+        _register_method(entity, "round", round)
+        setattr(entity, "__invert__", invert)
+
+        setattr(entity, "__add__", wrap_notimplemented_exception(add))
+        setattr(entity, "__radd__", wrap_notimplemented_exception(radd))
+        _register_bin_method(entity, "add", add)
+        _register_bin_method(entity, "radd", radd)
+
+        setattr(entity, "__sub__", wrap_notimplemented_exception(subtract))
+        setattr(entity, "__rsub__", wrap_notimplemented_exception(rsubtract))
+        _register_bin_method(entity, "sub", subtract)
+        _register_bin_method(entity, "rsub", rsubtract)
+
+        setattr(entity, "__mul__", wrap_notimplemented_exception(mul))
+        setattr(entity, "__rmul__", wrap_notimplemented_exception(rmul))
+        _register_bin_method(entity, "mul", mul)
+        _register_bin_method(entity, "multiply", mul)
+        _register_bin_method(entity, "rmul", rmul)
+
+        setattr(entity, "__floordiv__", wrap_notimplemented_exception(floordiv))
+        setattr(entity, "__rfloordiv__", wrap_notimplemented_exception(rfloordiv))
+        setattr(entity, "__truediv__", wrap_notimplemented_exception(truediv))
+        setattr(entity, "__rtruediv__", wrap_notimplemented_exception(rtruediv))
+        setattr(entity, "__div__", wrap_notimplemented_exception(truediv))
+        setattr(entity, "__rdiv__", wrap_notimplemented_exception(rtruediv))
+        _register_bin_method(entity, "floordiv", floordiv)
+        _register_bin_method(entity, "rfloordiv", rfloordiv)
+        _register_bin_method(entity, "truediv", truediv)
+        _register_bin_method(entity, "rtruediv", rtruediv)
+        _register_bin_method(entity, "div", truediv)
+        _register_bin_method(entity, "rdiv", rtruediv)
+
+        setattr(entity, "__mod__", wrap_notimplemented_exception(mod))
+        setattr(entity, "__rmod__", wrap_notimplemented_exception(rmod))
+        _register_bin_method(entity, "mod", mod)
+        _register_bin_method(entity, "rmod", rmod)
+
+        setattr(entity, "__pow__", wrap_notimplemented_exception(power))
+        setattr(entity, "__rpow__", wrap_notimplemented_exception(rpower))
+        _register_bin_method(entity, "pow", power)
+        _register_bin_method(entity, "rpow", rpower)
+
+        setattr(entity, "__eq__", _wrap_eq())
+        setattr(entity, "__ne__", _wrap_comparison(ne))
+        setattr(entity, "__lt__", _wrap_comparison(lt))
+        setattr(entity, "__gt__", _wrap_comparison(gt))
+        setattr(entity, "__ge__", _wrap_comparison(ge))
+        setattr(entity, "__le__", _wrap_comparison(le))
+        _register_bin_method(entity, "eq", eq)
+        _register_bin_method(entity, "ne", ne)
+        _register_bin_method(entity, "lt", lt)
+        _register_bin_method(entity, "gt", gt)
+        _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))
+
+        setattr(entity, "__or__", wrap_notimplemented_exception(bitor))
+        setattr(entity, "__ror__", wrap_notimplemented_exception(rbitor))
+
+        setattr(entity, "__xor__", wrap_notimplemented_exception(bitxor))
+        setattr(entity, "__rxor__", wrap_notimplemented_exception(rbitxor))
+
+        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())
+
+    if PdOpsMixin is not None and not hasattr(
+        pd, "_maxframe_df_arith_wrapped"
+    ):  # pragma: no branch
+        # wrap pandas magic functions to intercept reverse operators
+        for magic_name in [
+            "add",
+            "sub",
+            "mul",
+            "div",
+            "truediv",
+            "floordiv",
+            "mod",
+            "pow",
+            "and",
+            "or",
+            "xor",
+            "eq",
+            "ne",
+            "lt",
+            "le",
+            "gt",
+            "ge",
+        ]:
+            _wrap_pandas_magics(PdOpsMixin, magic_name)
+
+        for pd_cls in (pd.DataFrame, pd.Series):
+            _wrap_pandas_magics(pd_cls, "matmul")
+
+        pd._maxframe_df_arith_wrapped = True
+
+
+_install()
+del _install

maxframe/dataframe/arithmetic/abs.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.
+
+from ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameUnaryUfunc
+
+
+class DataFrameAbs(DataFrameUnaryUfunc):
+    _op_type_ = opcodes.ABS
+    _func_name = "abs"
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorAbsolute
+
+        return TensorAbsolute
+
+
+def abs_(df):
+    op = DataFrameAbs()
+    return op(df)