maxframe 1.3.0__cp37-cp37m-win32.whl → 2.0.0__cp37-cp37m-win32.whl

maxframe/codegen/spe/dataframe/indexing.py

@@ -0,0 +1,238 @@
+# 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 List
+
+from ....dataframe.core import DATAFRAME_TYPE, INDEX_TYPE
+from ....dataframe.indexing.align import DataFrameAlign
+from ....dataframe.indexing.getitem import DataFrameIndex, SeriesIndex
+from ....dataframe.indexing.iloc import DataFrameIlocGetItem, SeriesIlocGetItem
+from ....dataframe.indexing.insert import DataFrameInsert
+from ....dataframe.indexing.reindex import DataFrameReindex
+from ....dataframe.indexing.rename import DataFrameRename
+from ....dataframe.indexing.reset_index import DataFrameResetIndex
+from ....dataframe.indexing.sample import DataFrameSample
+from ....dataframe.indexing.set_axis import DataFrameSetAxis
+from ....dataframe.indexing.set_index import DataFrameSetIndex
+from ....dataframe.indexing.setitem import DataFrameSetitem
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+
+@register_op_adapter(DataFrameAlign)
+class DataFrameAlignAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameAlign, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        out_lhs_var = context.get_output_tileable_variable(op.outputs[0])
+        out_rhs_var = context.get_output_tileable_variable(op.outputs[1])
+        kw_keys = [
+            "join",
+            "axis",
+            "level",
+            "fill_value",
+            "method",
+            "limit",
+            "fill_axis",
+            "broadcast_axis",
+        ]
+        args_str = self.generate_call_args_with_attributes(
+            op, context, "rhs", skip_none=True, kw_keys=kw_keys
+        )
+        return [f"{out_lhs_var}, {out_rhs_var} = {input_var}.align({args_str})"]
+
+
+DataFrameInsertAdapter = build_method_call_adapter(
+    DataFrameInsert, "insert", kw_keys=["loc", "column", "value"], allow_duplicates=None
+)
+
+
+@register_op_adapter(SeriesIndex)
+class SeriesIndexAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: SeriesIndex, context: SPECodeContext) -> List[str]:
+        args = self._translate_call_args(context, op.labels)
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{output_var} = {input_var}[{', '.join(args)}]"]
+
+
+@register_op_adapter(DataFrameIndex)
+class DataFrameIndexAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameIndex, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        if op.col_names is not None:
+            args = ", ".join(self._translate_call_args(context, op.col_names))
+        else:
+            args = context.get_input_tileable_variable(op.mask)
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{output_var} = {input_var}[{args}]"]
+
+
+@register_op_adapter(DataFrameRename)
+class DataFrameRenameAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameRename, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+
+        if isinstance(op.outputs[0], INDEX_TYPE):
+            func_name = "set_names"
+            arg_list = [self.translate_var(context, op.index_mapper)]
+            arg_dict = {"level": self.translate_var(context, op.level)}
+        else:
+            func_name = "rename"
+            new_name_var = self.translate_var(context, op.new_name)
+            arg_list = []
+            arg_dict = {
+                "columns": self.translate_var(context, op.columns_mapper),
+                "index": self.translate_var(context, op.index_mapper),
+                "level": self.translate_var(context, op.level),
+                "errors": self.translate_var(context, op.errors),
+            }
+            if (
+                not isinstance(op.outputs[0], DATAFRAME_TYPE)
+                and op.new_name is not None
+            ):
+                arg_dict["index"] = new_name_var
+
+        arg_list += [f"{k}={v}" for k, v in arg_dict.items() if v != "None"]
+        arg_str = ", ".join(arg_list)
+        return [f"{output_var} = {input_var}.{func_name}({arg_str})"]
+
+
+@register_op_adapter(DataFrameSetAxis)
+class DataFrameSetAxisAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameSetAxis, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.input)
+        value_var = self.translate_var(context, op.value)
+        axis = self.translate_var(context, op.axis)
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        return [
+            f"{output_var} = {input_var}.set_axis({value_var}, axis={axis})",
+        ]
+
+
+@register_op_adapter(DataFrameSetitem)
+class DataFrameSetitemAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameSetitem, context: SPECodeContext) -> List[str]:
+        target_var = context.get_input_tileable_variable(op.target)
+        source_var = self.translate_var(context, op.value)
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        indexes = self.translate_var(context, op.indexes)
+        return [
+            f"{target_var}[{indexes}] = {source_var}",
+            f"{output_var} = {target_var}",
+        ]
+
+
+@register_op_adapter([SeriesIlocGetItem, DataFrameIlocGetItem])
+class DataFrameIlocGetItemAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: SeriesIlocGetItem, 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}.iloc[{row_exp}{col_exp}]"]
+
+
+@register_op_adapter(DataFrameSample)
+class DataFrameSampleAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameSample, context: SPECodeContext) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        kwargs = {
+            "n": op.size,
+            "frac": op.frac,
+            "replace": op.replace,
+            "weights": op.weights,
+            "axis": op.axis,
+        }
+        codes = list()
+        context.register_import("numpy", "np")
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        args_str = ", ".join(self._translate_call_args(context, **kwargs))
+        if op.random_state is not None:
+            rs_var = f"{res_var_name}_rs"
+            codes.append(f"{rs_var} = np.random.RandomState()")
+            rs_param = self.translate_var(context, op.random_state.get_state())
+            codes.append(f"{rs_var}.set_state({rs_param})")
+            args_str += f", random_state={rs_var}"
+        codes.append(f"{res_var_name} = {input_var_name}.sample({args_str})")
+        return codes
+
+
+@register_op_adapter(DataFrameResetIndex)
+class DataFrameResetIndexAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameResetIndex, context: SPECodeContext
+    ) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+
+        kwargs = {"level": op.level, "drop": op.drop, "inplace": False}
+
+        if isinstance(op.inputs[0], DATAFRAME_TYPE):
+            kwargs.update(
+                {
+                    "col_level": op.col_level,
+                    "col_fill": op.col_fill,
+                }
+            )
+        else:
+            kwargs.update(
+                {
+                    "name": op.name,
+                }
+            )
+
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        args_str = ", ".join(self._translate_call_args(context, **kwargs))
+
+        return [f"{res_var_name} = {input_var_name}.reset_index({args_str})"]
+
+
+@register_op_adapter(DataFrameSetIndex)
+class DataFrameSetIndexAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameSetIndex, context: SPECodeContext
+    ) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+
+        kwargs = {
+            "keys": op.keys,
+            "drop": op.drop,
+            "append": op.append,
+            "inplace": False,
+            "verify_integrity": op.verify_integrity,
+        }
+
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        args_str = ", ".join(self._translate_call_args(context, **kwargs))
+
+        return [f"{res_var_name} = {input_var_name}.set_index({args_str})"]
+
+
+DataFrameReindexAdapter = build_method_call_adapter(
+    DataFrameReindex,
+    "reindex",
+    skip_none=True,
+    kw_keys=[
+        "index",
+        "columns",
+        "method",
+        "level",
+        "fill_value",
+        "limit",
+    ],
+)

maxframe/codegen/spe/dataframe/merge.py

@@ -0,0 +1,73 @@
+# 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 List
+
+from ....dataframe.merge import DataFrameConcat, DataFrameMerge
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+
+
+@register_op_adapter(DataFrameMerge)
+class DataFrameMergeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameMerge, context: SPECodeContext) -> List[str]:
+        left_var = context.get_input_tileable_variable(op.inputs[0])
+        right_var = context.get_input_tileable_variable(op.inputs[1])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kwargs = {"how": op.how}
+        if op.how != "cross":
+            if op.on is not None:
+                kwargs["on"] = op.on
+            else:
+                if op.left_index:
+                    kwargs["left_index"] = True
+                else:
+                    kwargs["left_on"] = op.left_on
+
+                if op.right_index:
+                    kwargs["right_index"] = True
+                else:
+                    kwargs["right_on"] = op.right_on
+        kwargs["sort"] = op.sort
+        kwargs["suffixes"] = op.suffixes
+        kwargs["indicator"] = op.indicator
+        kwargs["validate"] = op.validate
+        kwargs["copy"] = op.copy_
+        args = ", ".join(self._translate_call_args(context, **kwargs))
+        context.register_import("pandas", "pd")
+        return [f"{res_var_name} = pd.merge({left_var}, {right_var}, {args})"]
+
+
+@register_op_adapter(DataFrameConcat)
+class DataFrameConcatAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameConcat, context: SPECodeContext) -> List[str]:
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_keys = [
+            "axis",
+            "join",
+            "ignore_index",
+            "keys",
+            "levels",
+            "names",
+            "verify_integrity",
+            "sort",
+        ]
+        args = self.generate_call_args_with_attributes(
+            op,
+            context,
+            kw_keys=kw_keys,
+            inputs="objs",
+            copy_="copy",
+        )
+        context.register_import("pandas", "pd")
+        return [f"{res_var_name} = pd.concat({args})"]

maxframe/codegen/spe/dataframe/misc.py

@@ -0,0 +1,286 @@
+# 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 Any, List
+
+from ....dataframe.core import DATAFRAME_TYPE, SERIES_TYPE, TILEABLE_TYPE
+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.cut import DataFrameCut
+from ....dataframe.misc.describe import DataFrameDescribe
+from ....dataframe.misc.diff import DataFrameDiff
+from ....dataframe.misc.drop import DataFrameDrop
+from ....dataframe.misc.drop_duplicates import DataFrameDropDuplicates
+from ....dataframe.misc.duplicated import DataFrameDuplicated
+from ....dataframe.misc.eval import DataFrameEval
+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 ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+DataFrameAstypeAdapter = build_method_call_adapter(
+    DataFrameAstype, "astype", "dtype_values"
+)
+
+
+@register_op_adapter(DataFrameCheckMonotonic)
+class DataFrameCheckMonotonicAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameCheckMonotonic, context: SPECodeContext
+    ) -> List[str]:
+        inst_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        if op.decreasing:
+            prop = "is_monotonic_decreasing"
+        else:
+            prop = "is_monotonic_increasing"
+        return [f"{res_var_name} = {inst_var_name}.{prop}"]
+
+
+@register_op_adapter(DataFrameCut)
+class DataFrameCutAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameCut, context: SPECodeContext) -> List[str]:
+        """ """
+        context.register_import("pandas", "pd")
+
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        kw_keys = [
+            "skip_none",
+            "right",
+            "labels",
+            "retbins",
+            "precision",
+            "include_lowest",
+            "duplicates",
+            "ordered",
+        ]
+        args = self.generate_call_args_with_attributes(
+            op, context, "_input", "bins", kw_keys=kw_keys
+        )
+        return [f"{res_var_name} = pd.cut({args})"]
+
+
+DataFrameDescribeAdapter = build_method_call_adapter(
+    DataFrameDescribe, "describe", kw_keys=["percentiles", "include", "exclude"]
+)
+DataFrameDiffAdapter = build_method_call_adapter(
+    DataFrameDiff, "diff", kw_keys=["periods", "axis"]
+)
+DataFrameDuplicatedAdapter = build_method_call_adapter(
+    DataFrameDuplicated, "duplicated", kw_keys=["subset", "keep"]
+)
+
+
+@register_op_adapter(DataFrameEval)
+class DataFrameEvalAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameEval, context: SPECodeContext) -> List[str]:
+        func_name = "query" if op.is_query else "eval"
+        inst_var_name = context.get_input_tileable_variable(op.inputs[0])
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        args_list = self._translate_call_args(context, op.expr)
+        args = ", ".join(args_list)
+        return [f"{res_var_name} = {inst_var_name}.{func_name}({args})"]
+
+
+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"]
+)
+
+
+@register_op_adapter(DataFrameIsin)
+class DataFrameIsinAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameIsin, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.input)
+        filter_var = self.translate_var(context, op.values)
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{output_var} = {input_var}.isin({filter_var})"]
+
+
+DataFrameMapAdapter = build_method_call_adapter(
+    DataFrameMap, "map", "arg", na_action=None
+)
+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)
+class DataFrameToNumericAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameToNumeric, context: SPECodeContext
+    ) -> List[str]:
+        context.register_import("pandas", "pd")
+
+        kw_keys = ["errors", "downcast"]
+        args = self.generate_call_args_with_attributes(
+            op, context, "input", kw_keys=kw_keys
+        )
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = pd.to_numeric({args})"]
+
+
+@register_op_adapter(TransformOperator)
+class TransformOperatorAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: TransformOperator, context: SPECodeContext
+    ) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        funcs_var = self.translate_var(context, op.func)
+        return [f"{output_var} = {input_var}.transform({funcs_var}, axis={op.axis})"]
+
+
+@register_op_adapter(DataFrameDrop)
+class DataFrameDropAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameDrop, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        args_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["index", "columns", "level", "errors"]
+        )
+        return [f"{output_var} = {input_var}.drop({args_str})"]
+
+
+@register_op_adapter(DataFrameApply)
+class DataFrameApplyAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameApply, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        applied_var = f"{output_var}_applied"
+        renamed_var = f"{output_var}_renamed"
+        if isinstance(op.inputs[0], DATAFRAME_TYPE):
+            apply_arg_list = ("func", "axis", "raw", "result_type")
+        else:
+            apply_arg_list = ("func", "convert_dtype")
+        apply_args = self.generate_call_args_with_attributes(
+            op, context, kw_keys=apply_arg_list
+        )
+
+        apply_code = f"{applied_var} = {input_var}.apply({apply_args})"
+
+        if isinstance(op.outputs[0], SERIES_TYPE):
+            rename_arg = self.translate_var(context, op.outputs[0].name)
+            rename_code = f"{renamed_var} = {applied_var}.rename({rename_arg})"
+            astype_arg = self.translate_var(context, op.outputs[0].dtype)
+            astype_node = f"{output_var} = {renamed_var}.astype({astype_arg})"
+        else:
+            rename_arg = self.translate_var(context, list(op.outputs[0].dtypes.index))
+            rename_code = f"{applied_var}.columns = {rename_arg}"
+            astype_arg = self.translate_var(context, dict(op.outputs[0].dtypes))
+            astype_node = f"{output_var} = {applied_var}.astype({astype_arg})"
+
+        return [apply_code, rename_code, astype_node]
+
+
+@register_op_adapter(DataFrameDropDuplicates)
+class DropDuplicatesOperatorAdapter(SPEOperatorAdapter):
+    def generate_code(
+        self, op: DataFrameDropDuplicates, context: SPECodeContext
+    ) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        if isinstance(op.inputs[0], DATAFRAME_TYPE):
+            arg_list = ("subset", "keep", "ignore_index")
+        elif isinstance(op.inputs[0], SERIES_TYPE):
+            arg_list = ("keep", "ignore_index")
+        else:
+            arg_list = ("keep",)
+        args = self.generate_call_args_with_attributes(op, context, kw_keys=arg_list)
+        return [f"{output_var} = {input_var}.drop_duplicates({args})"]
+
+
+@register_op_adapter(DataFrameCaseWhen)
+class CaseWhenOperatorAdapter(SPEOperatorAdapter):
+    @classmethod
+    def _get_case_expression(cls, expr: Any, context: SPECodeContext) -> str:
+        if isinstance(expr, TILEABLE_TYPE):
+            return context.get_input_tileable_variable(expr)
+        return cls.translate_var(context, expr)
+
+    def generate_code(
+        self, op: DataFrameCaseWhen, context: SPECodeContext
+    ) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+
+        cond_exprs = [
+            self._get_case_expression(cond, context) for cond in op.conditions
+        ]
+        repl_exprs = [
+            self._get_case_expression(repl, context) for repl in op.replacements
+        ]
+        case_list_items = [
+            f"({cond_expr}, {repr_expr})"
+            for cond_expr, repr_expr in zip(cond_exprs, repl_exprs)
+        ]
+        case_list = ", ".join(case_list_items)
+        return [f"{output_var} = {input_var}.case_when(caselist=[{case_list}])"]
+
+
+DataFrameGetDummiesAdapter = build_method_call_adapter(
+    DataFrameGetDummies,
+    "get_dummies",
+    "data",
+    kw_keys=[
+        "prefix",
+        "prefix_sep",
+        "dummy_na",
+        "columns",
+        "sparse",
+        "drop_first",
+        "dtype",
+    ],
+    source_module="pd",
+)

maxframe/codegen/spe/dataframe/missing.py

@@ -0,0 +1,64 @@
+# 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 List
+
+from ....dataframe.missing.checkna import DataFrameCheckNA
+from ....dataframe.missing.dropna import DataFrameDropNA
+from ....dataframe.missing.fillna import DataFrameFillNA
+from ....dataframe.missing.replace import DataFrameReplace
+from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+
+@register_op_adapter(DataFrameDropNA)
+class DataFrameDropNAAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameDropNA, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        args_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["axis", "how", "thresh", "subset"], skip_none=True
+        )
+        drop_idx_code = "" if not op.ignore_index else ".reset_index(drop=True)"
+        return [f"{output_var} = {input_var}.dropna({args_str}){drop_idx_code}"]
+
+
+DataFrameFillNAAdapter = build_method_call_adapter(
+    DataFrameFillNA,
+    "fillna",
+    skip_none=False,
+    kw_keys=["value", "method", "axis", "limit", "downcast"],
+)
+
+
+@register_op_adapter(DataFrameCheckNA)
+class DataFrameCheckNAAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameCheckNA, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        if op.positive:
+            return [f"{output_var} = {input_var}.isna()"]
+        else:
+            return [f"{output_var} = {input_var}.notna()"]
+
+
+@register_op_adapter(DataFrameReplace)
+class DataFrameReplaceAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameReplace, context: SPECodeContext) -> List[str]:
+        input_var = context.get_input_tileable_variable(op.inputs[0])
+        output_var = context.get_output_tileable_variable(op.outputs[0])
+        args_str = self.generate_call_args_with_attributes(
+            op, context, kw_keys=["to_replace", "value", "limit", "regex", "method"]
+        )
+        return [f"{output_var} = {input_var}.replace({args_str})"]