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

maxframe/codegen/spe/dataframe/indexing.py

@@ -12,15 +12,27 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List
+from typing import List, Union
 
 from ....dataframe.core import DATAFRAME_TYPE, INDEX_TYPE
 from ....dataframe.indexing.align import DataFrameAlign
+from ....dataframe.indexing.droplevel import DataFrameDropLevel
+from ....dataframe.indexing.filter import DataFrameFilter
+from ....dataframe.indexing.get_level_values import IndexGetLevelValues
 from ....dataframe.indexing.getitem import DataFrameIndex, SeriesIndex
-from ....dataframe.indexing.iloc import DataFrameIlocGetItem, SeriesIlocGetItem
+from ....dataframe.indexing.iloc import (
+    DataFrameIlocGetItem,
+    DataFrameIlocSetItem,
+    IndexIlocGetItem,
+    SeriesIlocGetItem,
+    SeriesIlocSetItem,
+)
 from ....dataframe.indexing.insert import DataFrameInsert
+from ....dataframe.indexing.loc import DataFrameLocGetItem, DataFrameLocSetItem
 from ....dataframe.indexing.reindex import DataFrameReindex
 from ....dataframe.indexing.rename import DataFrameRename
+from ....dataframe.indexing.rename_axis import DataFrameRenameAxis
+from ....dataframe.indexing.reorder_levels import DataFrameReorderLevels
 from ....dataframe.indexing.reset_index import DataFrameResetIndex
 from ....dataframe.indexing.sample import DataFrameSample
 from ....dataframe.indexing.set_axis import DataFrameSetAxis
@@ -52,6 +64,12 @@ class DataFrameAlignAdapter(SPEOperatorAdapter):
         return [f"{out_lhs_var}, {out_rhs_var} = {input_var}.align({args_str})"]
 
 
+DataFrameDropLevelAdapter = build_method_call_adapter(
+    DataFrameDropLevel, "droplevel", skip_none=True, kw_keys=["level", "axis"]
+)
+IndexGetLevelValuesAdapter = build_method_call_adapter(
+    IndexGetLevelValues, "get_level_values", "level"
+)
 DataFrameInsertAdapter = build_method_call_adapter(
     DataFrameInsert, "insert", kw_keys=["loc", "column", "value"], allow_duplicates=None
 )
@@ -134,10 +152,12 @@ class DataFrameSetitemAdapter(SPEOperatorAdapter):
         ]
 
 
-@register_op_adapter([SeriesIlocGetItem, DataFrameIlocGetItem])
+@register_op_adapter([DataFrameIlocGetItem, SeriesIlocGetItem, IndexIlocGetItem])
 class DataFrameIlocGetItemAdapter(SPEOperatorAdapter):
     def generate_code(
-        self, op: SeriesIlocGetItem, context: SPECodeContext
+        self,
+        op: Union[DataFrameIlocGetItem, SeriesIlocGetItem, IndexIlocGetItem],
+        context: SPECodeContext,
     ) -> List[str]:
         input_var = context.get_input_tileable_variable(op.inputs[0])
         output_var = context.get_output_tileable_variable(op.outputs[0])
@@ -148,6 +168,62 @@ class DataFrameIlocGetItemAdapter(SPEOperatorAdapter):
         return [f"{output_var} = {input_var}.iloc[{row_exp}{col_exp}]"]
 
 
+@register_op_adapter([DataFrameIlocSetItem, SeriesIlocSetItem])
+class DataFrameIlocSetItemAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self,
+        op: Union[DataFrameIlocSetItem, SeriesIlocSetItem],
+        context: SPECodeContext,
+    ) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        value_exp = self.translate_var(context, op.value)
+        row_exp = self.translate_var(context, op.indexes[0])
+        col_exp = ""
+        if len(op.indexes) > 1:
+            col_exp = f", {self.translate_var(context, op.indexes[1])}"
+        return [
+            f"{output_var} = {input_var}.copy()",
+            f"{output_var}.iloc[{row_exp}{col_exp}] = {value_exp}",
+        ]
+
+
+@register_op_adapter(DataFrameLocGetItem)
+class DataFrameLocGetItemAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self,
+        op: DataFrameLocGetItem,
+        context: SPECodeContext,
+    ) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        row_exp = self.translate_var(context, op.indexes[0])
+        col_exp = ""
+        if len(op.indexes) > 1:
+            col_exp = f", {self.translate_var(context, op.indexes[1])}"
+        return [f"{output_var} = {input_var}.loc[{row_exp}{col_exp}]"]
+
+
+@register_op_adapter(DataFrameLocSetItem)
+class DataFrameLocSetItemAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self,
+        op: DataFrameLocSetItem,
+        context: SPECodeContext,
+    ) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        value_exp = self.translate_var(context, op.value)
+        row_exp = self.translate_var(context, op.indexes[0])
+        col_exp = ""
+        if len(op.indexes) > 1:
+            col_exp = f", {self.translate_var(context, op.indexes[1])}"
+        return [
+            f"{output_var} = {input_var}.copy()",
+            f"{output_var}.loc[{row_exp}{col_exp}] = {value_exp}",
+        ]
+
+
 @register_op_adapter(DataFrameSample)
 class DataFrameSampleAdapter(SPEOperatorAdapter):
     def generate_code(self, op: DataFrameSample, context: SPECodeContext) -> List[str]:
@@ -236,3 +312,22 @@ DataFrameReindexAdapter = build_method_call_adapter(
         "limit",
     ],
 )
+
+DataFrameFilterAdapter = build_method_call_adapter(
+    DataFrameFilter,
+    "filter",
+    skip_none=True,
+    kw_keys=["items", "like", "regex", "axis"],
+)
+
+
+DataFrameReorderLevelsAdapter = build_method_call_adapter(
+    DataFrameReorderLevels, "reorder_levels", kw_keys=["order", "axis"]
+)
+
+DataFrameRenameAxisAdapter = build_method_call_adapter(
+    DataFrameRenameAxis,
+    "rename_axis",
+    skip_none=True,
+    kw_keys=["mapper", "index", "columns", "axis", "copy", "level", "inplace"],
+)

maxframe/codegen/spe/dataframe/merge.py

@@ -14,8 +14,20 @@
 
 from typing import List
 
-from ....dataframe.merge import DataFrameConcat, DataFrameMerge
+from ....dataframe.merge import (
+    DataFrameCompare,
+    DataFrameConcat,
+    DataFrameMerge,
+    DataFrameUpdate,
+)
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+DataFrameCompareAdapter = build_method_call_adapter(
+    DataFrameCompare,
+    "compare",
+    kw_keys=["align_axis", "keep_shape", "keep_equal", "result_names"],
+)
 
 
 @register_op_adapter(DataFrameMerge)
@@ -71,3 +83,24 @@ class DataFrameConcatAdapter(SPEOperatorAdapter):
         )
         context.register_import("pandas", "pd")
         return [f"{res_var_name} = pd.concat({args})"]
+
+
+@register_op_adapter(DataFrameUpdate)
+class DataFrameUpdateAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameUpdate, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        context.register_import("pandas", "pd")
+        if op.join == "outer":
+            method = "combine_first"
+            args = self.generate_call_args_with_attributes(op, context, 1)
+            return [f"{res_var_name} = {input_var}.{method}({args})"]
+        else:
+            method = "update"
+            args = self.generate_call_args_with_attributes(
+                op, context, 1, kw_keys=["join", "overwrite", "filter_func", "errors"]
+            )
+            return [
+                f"{res_var_name} = {input_var}.copy()",
+                f"{res_var_name}.{method}({args})",
+            ]

maxframe/codegen/spe/dataframe/misc.py

@@ -19,6 +19,7 @@ from ....dataframe.misc.apply import DataFrameApply
 from ....dataframe.misc.astype import DataFrameAstype
 from ....dataframe.misc.case_when import DataFrameCaseWhen
 from ....dataframe.misc.check_monotonic import DataFrameCheckMonotonic
+from ....dataframe.misc.clip import DataFrameClip
 from ....dataframe.misc.cut import DataFrameCut
 from ....dataframe.misc.describe import DataFrameDescribe
 from ....dataframe.misc.diff import DataFrameDiff
@@ -30,14 +31,10 @@ from ....dataframe.misc.explode import DataFrameExplode
 from ....dataframe.misc.get_dummies import DataFrameGetDummies
 from ....dataframe.misc.isin import DataFrameIsin
 from ....dataframe.misc.map import DataFrameMap
-from ....dataframe.misc.melt import DataFrameMelt
 from ....dataframe.misc.memory_usage import DataFrameMemoryUsage
-from ....dataframe.misc.pivot import DataFramePivot
-from ....dataframe.misc.pivot_table import DataFramePivotTable
 from ....dataframe.misc.shift import DataFrameShift
-from ....dataframe.misc.stack import DataFrameStack
 from ....dataframe.misc.to_numeric import DataFrameToNumeric
-from ....dataframe.misc.transform import TransformOperator
+from ....dataframe.misc.transform import DataFrameTransform
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
 from ..utils import build_method_call_adapter
 
@@ -60,6 +57,11 @@ class DataFrameCheckMonotonicAdapter(SPEOperatorAdapter):
         return [f"{res_var_name} = {inst_var_name}.{prop}"]
 
 
+DataFrameClipAdapter = build_method_call_adapter(
+    DataFrameClip, "clip", skip_none=True, kw_keys=["lower", "upper", "axis"]
+)
+
+
 @register_op_adapter(DataFrameCut)
 class DataFrameCutAdapter(SPEOperatorAdapter):
     def generate_code(self, op: DataFrameCut, context: SPECodeContext) -> List[str]:
@@ -108,11 +110,6 @@ class DataFrameEvalAdapter(SPEOperatorAdapter):
 DataFrameExplodeAdapter = build_method_call_adapter(
     DataFrameExplode, "explode", "column", ignore_index=None
 )
-DataFrameMeltAdapter = build_method_call_adapter(
-    DataFrameMelt,
-    "melt",
-    kw_keys=["id_vars", "value_vars", "var_name", "value_name", "col_level"],
-)
 DataFrameMemoryUsageAdapter = build_method_call_adapter(
     DataFrameMemoryUsage, "memory_usage", kw_keys=["index", "deep"]
 )
@@ -133,27 +130,6 @@ DataFrameMapAdapter = build_method_call_adapter(
 DataFrameShiftAdapter = build_method_call_adapter(
     DataFrameShift, "shift", kw_keys=["periods", "freq", "axis", "fill_value"]
 )
-DataFrameStackAdapter = build_method_call_adapter(
-    DataFrameStack, "stack", kw_keys=["level", "dropna"]
-)
-DataFramePivotAdapter = build_method_call_adapter(
-    DataFramePivot, "pivot", kw_keys=["columns", "index", "values"]
-)
-DataFramePivotTableAdapter = build_method_call_adapter(
-    DataFramePivotTable,
-    "pivot_table",
-    kw_keys=[
-        "values",
-        "index",
-        "columns",
-        "aggfunc",
-        "fill_value",
-        "margins",
-        "dropna",
-        "margins_name",
-        "sort",
-    ],
-)
 
 
 @register_op_adapter(DataFrameToNumeric)
@@ -171,10 +147,10 @@ class DataFrameToNumericAdapter(SPEOperatorAdapter):
         return [f"{res_var_name} = pd.to_numeric({args})"]
 
 
-@register_op_adapter(TransformOperator)
+@register_op_adapter(DataFrameTransform)
 class TransformOperatorAdapter(SPEOperatorAdapter):
     def generate_code(
-        self, op: TransformOperator, context: SPECodeContext
+        self, op: DataFrameTransform, context: SPECodeContext
     ) -> List[str]:
         input_var = context.get_input_tileable_variable(op.inputs[0])
         output_var = context.get_output_tileable_variable(op.outputs[0])

maxframe/codegen/spe/dataframe/reduction.py

@@ -18,7 +18,11 @@ from ....dataframe.reduction import (
     DataFrameAggregate,
     DataFrameAll,
     DataFrameAny,
+    DataFrameArgMax,
+    DataFrameArgMin,
     DataFrameCount,
+    DataFrameIdxMax,
+    DataFrameIdxMin,
     DataFrameKurtosis,
     DataFrameMax,
     DataFrameMean,
@@ -32,21 +36,18 @@ from ....dataframe.reduction import (
     DataFrameUnique,
     DataFrameVar,
 )
-from ....dataframe.reduction.core import (
-    DataFrameCumReductionOperator,
-    DataFrameReductionOperator,
-)
+from ....dataframe.reduction.core import DataFrameCumReduction, DataFrameReduction
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
 
 
-@register_op_adapter(DataFrameCumReductionOperator)
+@register_op_adapter(DataFrameCumReduction)
 class DataFrameCumsumAdapter(SPEOperatorAdapter):
     """
     TODO: Refine this in window functions
     """
 
     def generate_code(
-        self, op: DataFrameCumReductionOperator, context: SPECodeContext
+        self, op: DataFrameCumReduction, context: SPECodeContext
     ) -> List[str]:
         input_var_name = context.get_input_tileable_variable(op.inputs[0])
         args = []
@@ -78,7 +79,11 @@ class DataFrameAggregateAdapter(SPEOperatorAdapter):
     [
         DataFrameAll,
         DataFrameAny,
+        DataFrameArgMax,
+        DataFrameArgMin,
         DataFrameCount,
+        DataFrameIdxMax,
+        DataFrameIdxMin,
         DataFrameMax,
         DataFrameMean,
         DataFrameMedian,
@@ -90,13 +95,13 @@ class DataFrameAggregateAdapter(SPEOperatorAdapter):
 class DataFrameReductionAdapter(SPEOperatorAdapter):
     _common_args = ["axis", "skipna", "numeric_only", "bool_only", "level", "min_count"]
 
-    def extra_args(self, op: DataFrameReductionOperator) -> Dict[str, Any]:
+    def extra_args(self, op: DataFrameReduction) -> Dict[str, Any]:
         """
         Get the extra arguments of the API call.
 
         Parameters
         ----------
-        op : DataFrameReductionOperator
+        op : DataFrameReduction
             The DataFrameReductionOperator instance.
 
         Returns
@@ -107,7 +112,7 @@ class DataFrameReductionAdapter(SPEOperatorAdapter):
         return dict()
 
     def generate_code(
-        self, op: DataFrameReductionOperator, context: SPECodeContext
+        self, op: DataFrameReduction, context: SPECodeContext
     ) -> List[str]:
         input_var_name = context.get_input_tileable_variable(op.inputs[0])
         kwargs = dict()

maxframe/codegen/spe/dataframe/reshape.py

@@ -0,0 +1,46 @@
+# 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 ....dataframe.reshape.melt import DataFrameMelt
+from ....dataframe.reshape.pivot import DataFramePivot
+from ....dataframe.reshape.pivot_table import DataFramePivotTable
+from ....dataframe.reshape.stack import DataFrameStack
+from ..utils import build_method_call_adapter
+
+DataFrameMeltAdapter = build_method_call_adapter(
+    DataFrameMelt,
+    "melt",
+    kw_keys=["id_vars", "value_vars", "var_name", "value_name", "col_level"],
+)
+DataFrameStackAdapter = build_method_call_adapter(
+    DataFrameStack, "stack", kw_keys=["level", "dropna"]
+)
+DataFramePivotAdapter = build_method_call_adapter(
+    DataFramePivot, "pivot", kw_keys=["columns", "index", "values"]
+)
+DataFramePivotTableAdapter = build_method_call_adapter(
+    DataFramePivotTable,
+    "pivot_table",
+    kw_keys=[
+        "values",
+        "index",
+        "columns",
+        "aggfunc",
+        "fill_value",
+        "margins",
+        "dropna",
+        "margins_name",
+        "sort",
+    ],
+)

maxframe/codegen/spe/dataframe/sort.py

@@ -26,17 +26,27 @@ class _DataFrameSortAdapter(SPEOperatorAdapter):
         self, op: DataFrameSortOperator, context: SPECodeContext
     ) -> List[str]:
         input_var_name = context.get_input_tileable_variable(op.inputs[0])
-        kwargs = {
-            "axis": op.axis,
-            "ascending": op.ascending,
-            "inplace": op.inplace,
-            "na_position": op.na_position,
-            "ignore_index": op.ignore_index,
-        }
+        if op.keep_kind == "head" or not op.nrows:
+            args = []
+            kwargs = {
+                "axis": op.axis,
+                "ascending": op.ascending,
+                "inplace": op.inplace,
+                "na_position": op.na_position,
+                "ignore_index": op.ignore_index,
+            }
+        else:
+            args = [op.nrows]
+            kwargs = {"keep": op.keep_kind}
         kwargs.update(self.extra_args(op, context))
-        args_str = ", ".join(self._translate_call_args(context, **kwargs))
+        args_str = ", ".join(self._translate_call_args(context, *args, **kwargs))
         res_var_name = context.get_output_tileable_variable(op.outputs[0])
-        return [f"{res_var_name} = {input_var_name}.{self.method_name}({args_str})"]
+        ret = [
+            f"{res_var_name} = {input_var_name}.{self.get_method_name(op)}({args_str})"
+        ]
+        if op.keep_kind == "head" and op.nrows:
+            ret.append(f"{res_var_name} = {res_var_name}.head({op.nrows})")
+        return ret
 
     @abstractmethod
     def extra_args(
@@ -44,9 +54,8 @@ class _DataFrameSortAdapter(SPEOperatorAdapter):
     ) -> Dict[str, Any]:
         raise NotImplementedError
 
-    @property
     @abstractmethod
-    def method_name(self) -> str:
+    def get_method_name(self, op: DataFrameSortOperator) -> str:
         raise NotImplementedError
 
 
@@ -54,8 +63,7 @@ class _DataFrameSortAdapter(SPEOperatorAdapter):
 class DataFrameSortIndexAdapter(_DataFrameSortAdapter):
     _method_name = "sort_index"
 
-    @property
-    def method_name(self) -> str:
+    def get_method_name(self, op: DataFrameSortIndex) -> str:
         return self._method_name
 
     def extra_args(
@@ -71,13 +79,18 @@ class DataFrameSortIndexAdapter(_DataFrameSortAdapter):
 class DataFrameSortValuesAdapter(_DataFrameSortAdapter):
     _method_name = "sort_values"
 
-    @property
-    def method_name(self) -> str:
-        return self._method_name
+    def get_method_name(self, op: DataFrameSortValues) -> str:
+        if op.keep_kind == "head" or not op.nrows:
+            return self._method_name
+        else:
+            return "nsmallest" if op.ascending else "nlargest"
 
     def extra_args(
         self, op: DataFrameSortValues, context: SPECodeContext
     ) -> Dict[str, Any]:
         if isinstance(op.outputs[0], DATAFRAME_TYPE):
-            return {"by": op.by}
+            if op.keep_kind == "head" or not op.nrows:
+                return {"by": op.by}
+            else:
+                return {"columns": op.by}
         return {}

maxframe/codegen/spe/dataframe/tests/accessors/test_dict.py

@@ -21,13 +21,7 @@ from ...... import dataframe as md
 from ......lib.dtypes_extension import dict_
 from ......utils import ARROW_DTYPE_NOT_SUPPORTED
 from ....core import SPECodeContext
-from ...accessors.dict_ import (
-    SeriesDictContainsOperatorAdapter,
-    SeriesDictGetItemOperatorAdapter,
-    SeriesDictLengthOperatorAdapter,
-    SeriesDictRemoveOperatorAdapter,
-    SeriesDictSetItemOperatorAdapter,
-)
+from ...accessors.dict_ import SeriesDictMethodAdapter
 
 pytestmark = pytest.mark.skipif(
     ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
@@ -66,7 +60,7 @@ def md_df_1(pd_df_1):
 def test_getitem(md_df_1, pd_df_1):
     s1 = md_df_1["A"].dict["k1"]
     context = SPECodeContext()
-    adapter = SeriesDictGetItemOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -102,7 +96,7 @@ var_1.name = 'k1'
 def test_getitem_with_default_value(md_df_1, pd_df_1):
     s1 = md_df_1["A"].dict.get("k2", 9)
     context = SPECodeContext()
-    adapter = SeriesDictGetItemOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -137,7 +131,7 @@ var_1.name = 'k2'
 def test_getitem_with_key_error(md_df_1, pd_df_1):
     s1 = md_df_1["A"].dict["k2"]
     context = SPECodeContext()
-    adapter = SeriesDictGetItemOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -167,7 +161,7 @@ def test_setitem(md_df_1, pd_df_1):
     s1 = md_df_1["A"]
     s1.dict["k2"] = 9
     context = SPECodeContext()
-    adapter = SeriesDictSetItemOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -207,7 +201,7 @@ var_1 = var_0.map(_inner_set, na_action="ignore").astype(const_0)
 def test_length(md_df_1, pd_df_1):
     s1 = md_df_1["A"].dict.len()
     context = SPECodeContext()
-    adapter = SeriesDictLengthOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -227,7 +221,7 @@ var_1.name = None
 def test_remove_with_ignore_key_error(md_df_1, pd_df_1):
     s1 = md_df_1["A"].dict.remove("k2", ignore_key_error=True)
     context = SPECodeContext()
-    adapter = SeriesDictRemoveOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -262,7 +256,7 @@ var_1 = var_0.map(_inner_remove, na_action="ignore").astype(const_0)
 def test_remove_with_key_error(md_df_1, pd_df_1):
     s1 = md_df_1["A"].dict.remove("k2", ignore_key_error=False)
     context = SPECodeContext()
-    adapter = SeriesDictRemoveOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -290,7 +284,7 @@ var_1 = var_0.map(_inner_remove, na_action="ignore").astype(const_0)
 def test_contains(md_df_1, pd_df_1):
     s1 = md_df_1["A"].dict.contains("k2")
     context = SPECodeContext()
-    adapter = SeriesDictContainsOperatorAdapter()
+    adapter = SeriesDictMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [

maxframe/codegen/spe/dataframe/tests/accessors/test_list.py

@@ -21,10 +21,7 @@ from ...... import dataframe as md
 from ......lib.dtypes_extension import list_
 from ......utils import ARROW_DTYPE_NOT_SUPPORTED
 from ....core import SPECodeContext
-from ...accessors.list_ import (
-    SeriesListGetItemOperatorAdapter,
-    SeriesListLengthOperatorAdapter,
-)
+from ...accessors.list_ import SeriesListMethodAdapter
 
 pytestmark = pytest.mark.skipif(
     ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
@@ -63,7 +60,7 @@ def md_df_1(pd_df_1):
 def test_getitem(md_df_1, pd_df_1):
     s1 = md_df_1["A"].list.get(0)
     context = SPECodeContext()
-    adapter = SeriesListGetItemOperatorAdapter()
+    adapter = SeriesListMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -94,7 +91,7 @@ var_1.name = None
 def test_getitem_with_index_error(md_df_1, pd_df_1):
     s1 = md_df_1["A"].list[3]
     context = SPECodeContext()
-    adapter = SeriesListGetItemOperatorAdapter()
+    adapter = SeriesListMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [
@@ -120,7 +117,7 @@ var_1.name = None
 def test_length(md_df_1, pd_df_1):
     s1 = md_df_1["A"].list.len()
     context = SPECodeContext()
-    adapter = SeriesListLengthOperatorAdapter()
+    adapter = SeriesListMethodAdapter()
     results = adapter.generate_code(s1.op, context)
 
     expected_results = [

maxframe/codegen/spe/dataframe/tests/accessors/test_struct.py

@@ -0,0 +1,75 @@
+# 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 SPECodeContext
+from ...accessors.struct_ import SeriesStructMethodAdapter
+
+pytestmark = pytest.mark.skipif(
+    ARROW_DTYPE_NOT_SUPPORTED, reason="Arrow Dtype is not supported"
+)
+
+
+def _run_generated_code(
+    code: str, ctx: SPECodeContext, input_val: pd.DataFrame
+) -> dict:
+    local_vars = ctx.constants.copy()
+    local_vars["var_0"] = input_val
+    import_code = "import pandas as pd\nimport numpy as np\n"
+    exec(import_code + code, local_vars, local_vars)
+    return local_vars
+
+
+@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_field(series):
+    s1 = series.struct.field(["version", "minor"])
+    context = SPECodeContext()
+    adapter = SeriesStructMethodAdapter()
+    results = adapter.generate_code(s1.op, context)
+
+    expected_results = [
+        """
+var_1 = var_0.struct.field(['version', 'minor'])
+"""
+    ]
+    assert results == expected_results
+    local_vars = _run_generated_code(results[0], context, series.op.data)
+    expected_series = pd.Series(
+        [5, 1, 26], dtype=pd.ArrowDtype(pa.int64()), name="minor"
+    )
+    pd.testing.assert_series_equal(expected_series, local_vars["var_1"])