maxframe 2.0.0b2__cp39-cp39-win32.whl → 2.3.0rc1__cp39-cp39-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,24 @@
 
 from typing import List
 
-from ....dataframe.merge import DataFrameConcat, DataFrameMerge
+from ....dataframe.merge import (
+    DataFrameCombine,
+    DataFrameCompare,
+    DataFrameConcat,
+    DataFrameMerge,
+    DataFrameUpdate,
+)
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+DataFrameCombineAdapter = build_method_call_adapter(
+    DataFrameCombine, "combine", 1, "func", kw_keys=["fill_value"]
+)
+DataFrameCompareAdapter = build_method_call_adapter(
+    DataFrameCompare,
+    "compare",
+    kw_keys=["align_axis", "keep_shape", "keep_equal", "result_names"],
+)
 
 
 @register_op_adapter(DataFrameMerge)
@@ -71,3 +87,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,11 @@ 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.repeat import DataFrameRepeat
 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 +58,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 +111,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"]
 )
@@ -130,30 +128,10 @@ class DataFrameIsinAdapter(SPEOperatorAdapter):
 DataFrameMapAdapter = build_method_call_adapter(
     DataFrameMap, "map", "arg", na_action=None
 )
+DataFrameRepeatAdapter = build_method_call_adapter(DataFrameRepeat, "repeat", "repeats")
 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 +149,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,12 +18,17 @@ from ....dataframe.reduction import (
     DataFrameAggregate,
     DataFrameAll,
     DataFrameAny,
+    DataFrameArgMax,
+    DataFrameArgMin,
     DataFrameCount,
+    DataFrameIdxMax,
+    DataFrameIdxMin,
     DataFrameKurtosis,
     DataFrameMax,
     DataFrameMean,
     DataFrameMedian,
     DataFrameMin,
+    DataFrameMode,
     DataFrameNunique,
     DataFrameProd,
     DataFrameSem,
@@ -32,21 +37,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 +80,11 @@ class DataFrameAggregateAdapter(SPEOperatorAdapter):
     [
         DataFrameAll,
         DataFrameAny,
+        DataFrameArgMax,
+        DataFrameArgMin,
         DataFrameCount,
+        DataFrameIdxMax,
+        DataFrameIdxMin,
         DataFrameMax,
         DataFrameMean,
         DataFrameMedian,
@@ -90,13 +96,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 +113,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()
@@ -158,3 +164,20 @@ class DataFrameUniqueAdapter(SPEOperatorAdapter):
         input_var_name = context.get_input_tileable_variable(op.inputs[0])
         res_var_name = context.get_output_tileable_variable(op.outputs[0])
         return [f"{res_var_name} = pd.unique({input_var_name})"]
+
+
+@register_op_adapter(DataFrameMode)
+class DataFrameModeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameMode, context: SPECodeContext) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        args = []
+        if op.inputs[0].ndim == 2:
+            if op.axis is not None:
+                args.append(f"axis={op.axis!r}")
+            if op.numeric_only is not None:
+                args.append(f"numeric_only={op.numeric_only!r}")
+        if op.dropna is not None:
+            args.append(f"dropna={op.dropna!r}")
+        args_str = ", ".join(args)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = {input_var_name}.mode({args_str})"]

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

@@ -16,9 +16,17 @@ from abc import abstractmethod
 from typing import Any, Dict, List
 
 from ....dataframe.core import DATAFRAME_TYPE
-from ....dataframe.sort import DataFrameSortIndex, DataFrameSortValues
+from ....dataframe.sort import DataFrameRank, DataFrameSortIndex, DataFrameSortValues
 from ....dataframe.sort.core import DataFrameSortOperator
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+DataFrameRankAdapter = build_method_call_adapter(
+    DataFrameRank,
+    "rank",
+    kw_keys=["axis", "method", "numeric_only", "na_option", "ascending", "pct"],
+    skip_none=True,
+)
 
 
 class _DataFrameSortAdapter(SPEOperatorAdapter):
@@ -26,17 +34,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 +62,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 +71,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 +87,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 = [