maxframe 2.0.0b2__cp38-cp38-win_amd64.whl → 2.2.0__cp38-cp38-win_amd64.whl

maxframe/dataframe/accessors/dict_/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 SeriesDictMethod(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.SERIES_DICT_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 LegacySeriesDictOperator(LegacySeriesMethodOperator):
+    _method_cls = SeriesDictMethod

maxframe/dataframe/accessors/dict_/getitem.py

@@ -15,30 +15,18 @@
 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 LegacySeriesDictOperator, SeriesDictMethod
 
 
-class SeriesDictGetItemOperator(DataFrameOperator, DataFrameOperatorMixin):
+class SeriesDictGetItemOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
     _op_type_ = opcodes.SERIES_DICT_GETITEM
+    _method_name = "getitem"
     query_key = AnyField("query_key", default=None)
     default_value = AnyField("default_value", default=None)
     ignore_key_error = BoolField("ignore_key_error", default=False)
 
-    def __init__(self, **kw):
-        super().__init__(_output_types=[OutputType.series], **kw)
-
-    def __call__(self, series):
-        arrow_map_type = series.dtype.pyarrow_dtype
-        return self.new_series(
-            [series],
-            shape=series.shape,
-            dtype=pd.ArrowDtype(arrow_map_type.item_type),
-            index_value=series.index_value,
-            name=str(self.query_key),
-        )
-
 
 def series_dict_getitem(series, query_key, default_value=None):
     """
@@ -85,9 +73,14 @@ def series_dict_getitem(series, query_key, default_value=None):
     3    <NA>
     Name: k2, dtype: int64[pyarrow]
     """
-    return SeriesDictGetItemOperator(
+    method_kw = dict(
         query_key=query_key, default_value=default_value, ignore_key_error=True
-    )(series)
+    )
+    arrow_map_type = series.dtype.pyarrow_dtype
+    dtype = pd.ArrowDtype(arrow_map_type.item_type)
+    return SeriesDictMethod(method="getitem", method_kwargs=method_kw)(
+        series, name=str(query_key), dtype=dtype
+    )
 
 
 def series_dict_getitem_with_key_error(series, query_key):
@@ -139,6 +132,9 @@ def series_dict_getitem_with_key_error(series, query_key):
     3    <NA>
     Name: k1, dtype: int64[pyarrow]
     """
-    return SeriesDictGetItemOperator(
-        query_key=query_key, default_value=None, ignore_key_error=False
-    )(series)
+    method_kw = dict(query_key=query_key, default_value=None, ignore_key_error=False)
+    arrow_map_type = series.dtype.pyarrow_dtype
+    dtype = pd.ArrowDtype(arrow_map_type.item_type)
+    return SeriesDictMethod(method="getitem", method_kwargs=method_kw)(
+        series, name=str(query_key), dtype=dtype
+    )

maxframe/dataframe/accessors/dict_/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 LegacySeriesDictOperator, SeriesDictMethod
 
 
-class SeriesDictLengthOperator(DataFrameOperator, DataFrameOperatorMixin):
+class SeriesDictLengthOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
     _op_type_ = opcodes.SERIES_DICT_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_dict_length(series):
@@ -70,4 +59,6 @@ def series_dict_length(series):
     3    <NA>
     dtype: int64[pyarrow]
     """
-    return SeriesDictLengthOperator()(series)
+    return SeriesDictMethod(method="len")(
+        series, name=None, dtype=pd.ArrowDtype(pa.int64())
+    )

maxframe/dataframe/accessors/dict_/remove.py

@@ -13,28 +13,17 @@
 # limitations under the License.
 
 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 LegacySeriesDictOperator, SeriesDictMethod
 
 
-class SeriesDictRemoveOperator(DataFrameOperator, DataFrameOperatorMixin):
+class SeriesDictRemoveOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
     _op_type_ = opcodes.SERIES_DICT_REMOVE
+    _method_name = "remove"
     query_key = AnyField("query_key", default=None)
     ignore_key_error = BoolField("ignore_key_error", default=False)
 
-    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=series.dtype,
-            name=series.name,
-        )
-
 
 def series_dict_remove(series, query_key, ignore_key_error: bool = False):
     """
@@ -82,6 +71,5 @@ def series_dict_remove(series, query_key, ignore_key_error: bool = False):
     3           <NA>
     dtype: map<string, int64>[pyarrow]
     """
-    return SeriesDictRemoveOperator(
-        query_key=query_key, ignore_key_error=ignore_key_error
-    )(series)
+    method_kwargs = dict(query_key=query_key, ignore_key_error=ignore_key_error)
+    return SeriesDictMethod(method="remove", method_kwargs=method_kwargs)(series)

maxframe/dataframe/accessors/dict_/setitem.py

@@ -13,30 +13,18 @@
 # limitations under the License.
 
 from .... import opcodes
-from ....core.entity.output_types import OutputType
 from ....serialization.serializables.field import AnyField
 from ...core import TILEABLE_TYPE
-from ...operators import DataFrameOperator, DataFrameOperatorMixin
+from .core import LegacySeriesDictOperator, SeriesDictMethod
 
 
-class SeriesDictSetItemOperator(DataFrameOperator, DataFrameOperatorMixin):
+class SeriesDictSetItemOperator(LegacySeriesDictOperator):
+    # operator class deprecated since v2.3.0
     _op_type_ = opcodes.SERIES_DICT_SETITEM
+    _method_name = "setitem"
     query_key = AnyField("query_key", default=None)
     value = AnyField("default_value", default=None)
 
-    def __init__(self, **kw):
-        super().__init__(_output_types=[OutputType.series], **kw)
-
-    def __call__(self, series):
-        new_series = self.new_series(
-            [series],
-            shape=series.shape,
-            index_value=series.index_value,
-            dtype=series.dtype,
-            name=series.name,
-        )
-        series.data = new_series.data
-
 
 def series_dict_setitem(series, query_key, value):
     """
@@ -67,7 +55,7 @@ def series_dict_setitem(series, query_key, value):
     >>> s = md.Series(
     ...     data=[[("k1", 1), ("k2", 2)], [("k1", 3)], None],
     ...     index=[1, 2, 3],
-    ...     dtype=map_(pa.string(), pa.int64()),
+    ...     dtype=dict_(pa.string(), pa.int64()),
     ... )
     >>> s.execute()
     1    [('k1', 1), ('k2', 2)]
@@ -86,4 +74,6 @@ def series_dict_setitem(series, query_key, value):
         raise NotImplementedError(
             "Set the value with a dataframe/series is not allowed yet"
         )
-    return SeriesDictSetItemOperator(query_key=query_key, value=value)(series)
+    method_kwargs = dict(query_key=query_key, value=value)
+    new_series = SeriesDictMethod(method="setitem", method_kwargs=method_kwargs)(series)
+    series.data = new_series.data

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")