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

maxframe/dataframe/accessors/dict_/tests/test_dict_accessor.py

@@ -18,13 +18,15 @@ import pyarrow as pa
 import pytest
 
 from ..... import dataframe as md
+from .....core import OutputType, TileableGraph, build_fetch
 from .....lib.dtypes_extension import dict_
-from .....utils import ARROW_DTYPE_NOT_SUPPORTED
-from ..contains import SeriesDictContainsOperator
+from .....utils import (
+    ARROW_DTYPE_NOT_SUPPORTED,
+    deserialize_serializable,
+    serialize_serializable,
+)
+from ..core import SeriesDictMethod
 from ..getitem import SeriesDictGetItemOperator
-from ..length import SeriesDictLengthOperator
-from ..remove import SeriesDictRemoveOperator
-from ..setitem import SeriesDictSetItemOperator
 
 pytestmark = pytest.mark.skipif(
     ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
@@ -58,10 +60,11 @@ def test_getitem(df):
     assert s1.shape == (1,)
     assert s1.index_value == df.index_value
     op = s1.op
-    assert isinstance(op, SeriesDictGetItemOperator)
-    assert op.query_key == "k1"
-    assert op.default_value is None
-    assert op.ignore_key_error is False
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "getitem"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["default_value"] is None
+    assert op.method_kwargs["ignore_key_error"] is False
 
 
 def test_getitem_with_default_value(df):
@@ -72,10 +75,11 @@ def test_getitem_with_default_value(df):
     assert s1.shape == (1,)
     assert s1.index_value == df.index_value
     op = s1.op
-    assert isinstance(op, SeriesDictGetItemOperator)
-    assert op.query_key == "k1"
-    assert op.default_value == 1
-    assert op.ignore_key_error is True
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "getitem"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["default_value"] == 1
+    assert op.method_kwargs["ignore_key_error"] is True
 
 
 def test_setitem(df):
@@ -87,9 +91,10 @@ def test_setitem(df):
     assert s1.index_value == df.index_value
     assert s1.shape == (1,)
     op = s1.op
-    assert isinstance(op, SeriesDictSetItemOperator)
-    assert op.query_key == "k1"
-    assert op.value == "v3"
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "setitem"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["value"] == "v3"
 
 
 def test_length(df):
@@ -100,7 +105,8 @@ def test_length(df):
     assert s1.shape == (1,)
     assert s1.index_value == df.index_value
     op = s1.op
-    assert isinstance(op, SeriesDictLengthOperator)
+    assert op.method == "len"
+    assert isinstance(op, SeriesDictMethod)
 
 
 def test_remove(df):
@@ -111,9 +117,10 @@ def test_remove(df):
     assert s1.index_value == df.index_value
     assert s1.shape == (1,)
     op = s1.op
-    assert isinstance(op, SeriesDictRemoveOperator)
-    assert op.query_key == "k1"
-    assert op.ignore_key_error is True
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "remove"
+    assert op.method_kwargs["query_key"] == "k1"
+    assert op.method_kwargs["ignore_key_error"] is True
 
 
 def test_contains(df):
@@ -124,5 +131,38 @@ def test_contains(df):
     assert s1.index_value == df.index_value
     assert s1.shape == (1,)
     op = s1.op
-    assert isinstance(op, SeriesDictContainsOperator)
-    assert op.query_key == "k1"
+    assert isinstance(op, SeriesDictMethod)
+    assert op.method == "contains"
+    assert op.method_kwargs["query_key"] == "k1"
+
+
+def test_legacy_compatibility(df):
+    in_series = df["A"]
+    legacy_op = SeriesDictGetItemOperator(
+        query_key="k1",
+        default_value=1,
+        ignore_key_error=True,
+        _output_types=[OutputType.series],
+    )
+    out = legacy_op.new_tileable(
+        [in_series],
+        shape=in_series.shape,
+        index_value=in_series.index_value,
+        name="k1",
+        dtype=pd.ArrowDtype(pa.int64()),
+    )
+    fetch_node = build_fetch(in_series).data
+    out.op.inputs = [fetch_node]
+
+    dag = TileableGraph([out.data])
+    dag.add_node(fetch_node)
+    dag.add_node(out.data)
+    dag.add_edge(fetch_node, out.data)
+    dag_out = deserialize_serializable(serialize_serializable(dag))
+
+    out_op = dag_out.results[0].op
+    assert isinstance(out_op, SeriesDictMethod)
+    assert out_op.method == "getitem"
+    assert out_op.method_kwargs["ignore_key_error"] == True
+    assert out_op.method_kwargs["default_value"] == 1
+    assert out_op.method_kwargs["query_key"] == "k1"

maxframe/dataframe/accessors/list_/__init__.py

@@ -20,13 +20,13 @@ def _install():
     from .getitem import series_list_getitem, series_list_getitem_with_index_error
     from .length import series_list_length
 
-    dict_method_to_handlers = {
+    list_method_to_handlers = {
         "__getitem__": series_list_getitem_with_index_error,
         "get": series_list_getitem,
         "len": series_list_length,
     }
 
-    for name, handler in dict_method_to_handlers.items():
+    for name, handler in list_method_to_handlers.items():
         ListAccessor._register(name, handler)
 
     for series in SERIES_TYPE:

maxframe/dataframe/accessors/list_/core.py

@@ -0,0 +1,48 @@
+# 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
+from ..compat import LegacySeriesMethodOperator
+
+
+class SeriesListMethod(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_LIST_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 or 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,
+        )
+
+
+class LegacySeriesListOperator(LegacySeriesMethodOperator):
+    _method_cls = SeriesListMethod

maxframe/dataframe/accessors/list_/getitem.py

@@ -15,28 +15,17 @@
 import pandas as pd
 
 from .... import opcodes
-from ....core.entity.output_types import OutputType
 from ....serialization.serializables.field import AnyField, BoolField
-from ...operators import DataFrameOperator, DataFrameOperatorMixin
+from .core import LegacySeriesListOperator, SeriesListMethod
 
 
-class SeriesListGetItemOperator(DataFrameOperator, DataFrameOperatorMixin):
+class SeriesListGetItemOperator(LegacySeriesListOperator):
+    # operator class deprecated since v2.3.0
     _op_type_ = opcodes.SERIES_LIST_GETITEM
+    _method_name = "getitem"
     query_index = AnyField("query_index", default=None)
     ignore_index_error = BoolField("ignore_index_error", default=False)
 
-    def __init__(self, **kw):
-        super().__init__(_output_types=[OutputType.series], **kw)
-
-    def __call__(self, series):
-        arrow_list_type = series.dtype.pyarrow_dtype
-        return self.new_series(
-            [series],
-            shape=series.shape,
-            dtype=pd.ArrowDtype(arrow_list_type.value_type),
-            index_value=series.index_value,
-        )
-
 
 def series_list_getitem(series, query_index):
     """
@@ -77,8 +66,10 @@ def series_list_getitem(series, query_index):
     3    <NA>
     dtype: int64[pyarrow]
     """
-    return SeriesListGetItemOperator(query_index=query_index, ignore_index_error=True)(
-        series
+    kw = dict(query_index=query_index, ignore_index_error=True)
+    arrow_list_type = series.dtype.pyarrow_dtype
+    return SeriesListMethod(method="getitem", method_kwargs=kw)(
+        series, dtype=pd.ArrowDtype(arrow_list_type.value_type)
     )
 
 
@@ -130,6 +121,8 @@ def series_list_getitem_with_index_error(series, query_index):
     3    <NA>
     dtype: int64[pyarrow]
     """
-    return SeriesListGetItemOperator(query_index=query_index, ignore_index_error=False)(
-        series
+    kw = dict(query_index=query_index, ignore_index_error=False)
+    arrow_list_type = series.dtype.pyarrow_dtype
+    return SeriesListMethod(method="getitem", method_kwargs=kw)(
+        series, dtype=pd.ArrowDtype(arrow_list_type.value_type)
     )

maxframe/dataframe/accessors/list_/length.py

@@ -16,24 +16,13 @@ import pandas as pd
 import pyarrow as pa
 
 from .... import opcodes
-from ....core.entity.output_types import OutputType
-from ...operators import DataFrameOperator, DataFrameOperatorMixin
+from .core import LegacySeriesListOperator, SeriesListMethod
 
 
-class SeriesListLengthOperator(DataFrameOperator, DataFrameOperatorMixin):
+class SeriesListLengthOperator(LegacySeriesListOperator):
+    # operator class deprecated since v2.3.0
     _op_type_ = opcodes.SERIES_LIST_LENGTH
-
-    def __init__(self, **kw):
-        super().__init__(_output_types=[OutputType.series], **kw)
-
-    def __call__(self, series):
-        return self.new_series(
-            [series],
-            shape=series.shape,
-            index_value=series.index_value,
-            dtype=pd.ArrowDtype(pa.int64()),
-            name=None,
-        )
+    _method_name = "len"
 
 
 def series_list_length(series):
@@ -70,4 +59,6 @@ def series_list_length(series):
     3    <NA>
     dtype: int64[pyarrow]
     """
-    return SeriesListLengthOperator()(series)
+    return SeriesListMethod(method="len")(
+        series, name=None, dtype=pd.ArrowDtype(pa.int64())
+    )

maxframe/dataframe/accessors/list_/tests/test_list_accessor.py

@@ -20,8 +20,7 @@ import pytest
 from ..... import dataframe as md
 from .....lib.dtypes_extension import list_
 from .....utils import ARROW_DTYPE_NOT_SUPPORTED
-from ..getitem import SeriesListGetItemOperator
-from ..length import SeriesListLengthOperator
+from ..core import SeriesListMethod
 
 pytestmark = pytest.mark.skipif(
     ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
@@ -52,9 +51,10 @@ def test_getitem(df):
     assert s1.shape == (1,)
     assert s1.index_value == df.index_value
     op = s1.op
-    assert isinstance(op, SeriesListGetItemOperator)
-    assert op.query_index == 1
-    assert op.ignore_index_error is False
+    assert isinstance(op, SeriesListMethod)
+    assert op.method == "getitem"
+    assert op.method_kwargs["query_index"] == 1
+    assert op.method_kwargs["ignore_index_error"] is False
 
 
 def test_getitem_ignore_index_err(df):
@@ -64,9 +64,10 @@ def test_getitem_ignore_index_err(df):
     assert s1.shape == (1,)
     assert s1.index_value == df.index_value
     op = s1.op
-    assert isinstance(op, SeriesListGetItemOperator)
-    assert op.query_index == 1
-    assert op.ignore_index_error is True
+    assert isinstance(op, SeriesListMethod)
+    assert op.method == "getitem"
+    assert op.method_kwargs["query_index"] == 1
+    assert op.method_kwargs["ignore_index_error"] is True
 
 
 def test_length(df):
@@ -76,4 +77,5 @@ def test_length(df):
     assert s1.shape == (1,)
     assert s1.index_value == df.index_value
     op = s1.op
-    assert isinstance(op, SeriesListLengthOperator)
+    assert isinstance(op, SeriesListMethod)
+    assert op.method == "len"

maxframe/dataframe/accessors/string_/__init__.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .core import SeriesStringMethod
+from .core import SeriesStringMethod, string_method_to_handlers
+
+methods = set(string_method_to_handlers.keys())
+del string_method_to_handlers
 
 
 def _install():

maxframe/dataframe/accessors/struct_/__init__.py

@@ -0,0 +1,37 @@
+# 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 CachedAccessor
+    from ...core import SERIES_TYPE
+    from .accessor import StructAccessor
+    from .dtypes import struct_dtypes
+    from .field import struct_field
+
+    struct_method_to_handlers = {
+        "dtypes": struct_dtypes,
+        "field": struct_field,
+    }
+    property_names = {"dtypes"}
+
+    for name, handler in struct_method_to_handlers.items():
+        StructAccessor._register(name, handler, is_property=name in property_names)
+
+    for series in SERIES_TYPE:
+        series.struct = CachedAccessor("struct", StructAccessor)
+
+
+_install()
+del _install

maxframe/dataframe/accessors/struct_/accessor.py

@@ -0,0 +1,39 @@
+# 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 TYPE_CHECKING
+
+import pandas as pd
+import pyarrow as pa
+
+from ....core import BaseMaxFrameAccessor
+from ....utils import ARROW_DTYPE_NOT_SUPPORTED
+
+if TYPE_CHECKING:
+    from ...core import Series
+
+
+class StructAccessor(BaseMaxFrameAccessor):
+    obj: "Series"
+    _api_count: int = 0
+
+    def __init__(self, series):
+        super().__init__(series)
+        if ARROW_DTYPE_NOT_SUPPORTED:
+            raise ImportError("pd.ArrowDtype is not supported in current environment")
+
+        if not isinstance(series.dtype, pd.ArrowDtype) or not isinstance(
+            series.dtype.pyarrow_dtype, pa.StructType
+        ):
+            raise AttributeError("Can only use .struct accessor with struct values")

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.