maxframe 1.3.1__cp39-cp39-win_amd64.whl → 2.0.0__cp39-cp39-win_amd64.whl

maxframe/codegen/spe/dataframe/tests/indexing/test_set_index.py

@@ -0,0 +1,41 @@
+# 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 pytest
+
+from ....core import SPECodeContext
+from ...indexing import DataFrameSetIndexAdapter
+
+
+@pytest.mark.parametrize(
+    "keys,drop,append,verify_integrity",
+    [
+        ("A", True, False, False),
+        (["C", "D"], True, False, False),
+        (["C", "D"], True, True, False),
+        (["C", "D"], True, False, True),
+    ],
+)
+def test_dataframe_set_index(df1, keys, drop, append, verify_integrity):
+    _df1 = df1.set_index(
+        keys=keys, drop=drop, append=append, verify_integrity=verify_integrity
+    )
+    context = SPECodeContext()
+    adapter = DataFrameSetIndexAdapter()
+    results = adapter.generate_code(_df1.op, context)
+
+    expected_results = [
+        f"var_1 = var_0.set_index(keys={repr(keys)}, drop={drop}, append={append}, inplace=False, verify_integrity={verify_integrity})"
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/indexing/test_setitem.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.
+
+import numpy as np
+
+from ....core import SPECodeContext
+from ...indexing import DataFrameSetitemAdapter
+
+
+def test_dataframe_setitem_with_scalar_to_one_index(df1):
+    df1["A"] = np.intc(100)
+    context = SPECodeContext()
+    adapter = DataFrameSetitemAdapter()
+    results = adapter.generate_code(df1.op, context)
+    expected_results = ["var_0['A'] = const_0", "var_1 = var_0"]
+    assert context.constants["const_0"] == 100
+    assert results == expected_results
+
+
+def test_dataframe_setitem_with_scalar_to_multi_indexes(df1):
+    df1[["A", "E"]] = 100
+    context = SPECodeContext()
+    adapter = DataFrameSetitemAdapter()
+    results = adapter.generate_code(df1.op, context)
+    expected_results = ["var_0[['A', 'E']] = 100", "var_1 = var_0"]
+    assert results == expected_results
+
+
+def test_dataframe_setitem_with_non_scalar(df1):
+    df1[["A", "E"]] = df1[["A", "B"]]
+    context = SPECodeContext()
+    adapter = DataFrameSetitemAdapter()
+    results = adapter.generate_code(df1.op, context)
+    expected_results = ["var_0[['A', 'E']] = var_1", "var_2 = var_0"]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/misc/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

maxframe/codegen/spe/dataframe/tests/misc/test_apply.py

@@ -0,0 +1,133 @@
+# 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 pytest
+
+from ...... import dataframe as md
+from ....core import SPECodeContext
+from ...misc import DataFrameApplyAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        [
+            [1, 10, 101],
+            [9, 90, 909],
+            [2, 20, 202],
+        ],
+        index=pd.MultiIndex.from_arrays(
+            [[1, 9, 2], [11, 99, 22], [111, 999, 222]],
+            names=("idx_0", "idx_1", "idx_2"),
+        ),
+        columns=list("ABC"),
+    )
+
+
+@pytest.fixture
+def s1():
+    return md.Series([5, 2, 3, 1], index=[5, 2, 3, 1], name="A")
+
+
+def test_series_apply(s1):
+    s = s1.apply(lambda x: x + 1, convert_dtype=True)
+    adapter = DataFrameApplyAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(s.op, context)
+    assert len(context.get_udfs()) == 1
+    f = context.get_udfs()[0]
+    expected_results = [
+        f"var_1_applied = var_0.apply(func={f.name}, convert_dtype=True)",
+        "var_1_renamed = var_1_applied.rename('A')",
+        "var_1 = var_1_renamed.astype(np.dtype('int64'))",
+    ]
+    assert results == expected_results
+
+
+def test_apply_with_series_dtype_and_name(s1):
+    s = s1.apply(
+        lambda x: x + 1,
+        convert_dtype=False,
+        name="X",
+        dtype="float32",
+        output_type="series",
+    )
+    adapter = DataFrameApplyAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(s.op, context)
+    assert len(context.get_udfs()) == 1
+    f = context.get_udfs()[0]
+    expected_results = [
+        f"var_1_applied = var_0.apply(func={f.name}, convert_dtype=False)",
+        "var_1_renamed = var_1_applied.rename('X')",
+        "var_1 = var_1_renamed.astype(np.dtype('float32'))",
+    ]
+    assert results == expected_results
+
+
+def test_apply_with_dataframe_dtypes(df1):
+    df = df1.apply(
+        lambda x: pd.Series([str(x), x + 1]),
+        convert_dtype=False,
+        dtypes=pd.Series(["object", "float64"], index=["X", "Y"]),
+        output_type="dataframe",
+    )
+    adapter = DataFrameApplyAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    assert len(context.get_udfs()) == 1
+    f = context.get_udfs()[0]
+    expected_results = [
+        f"var_1_applied = var_0.apply(func={f.name}, axis=0, raw=False, result_type=None)",
+        "var_1_applied.columns = ['X', 'Y']",
+        "var_1 = var_1_applied.astype({'X': np.dtype('object'), 'Y': np.dtype('float64')})",
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_apply_column(df1):
+    df = df1.apply(lambda x: x + 1, axis=0)
+    adapter = DataFrameApplyAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    assert len(context.get_udfs()) == 1
+    f = context.get_udfs()[0]
+    expected_results = [
+        f"var_1_applied = var_0.apply(func={f.name}, axis=0, raw=False, result_type=None)",
+        "var_1_applied.columns = ['A', 'B', 'C']",
+        "var_1 = var_1_applied.astype("
+        "{'A': np.dtype('int64'),"
+        " 'B': np.dtype('int64'),"
+        " 'C': np.dtype('int64')})",
+    ]
+    assert results == expected_results
+
+
+def test_dataframe_apply_row(df1):
+    df = df1.apply(lambda x: x + 1, 1, True, "expand")
+    adapter = DataFrameApplyAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    assert len(context.get_udfs()) == 1
+    f = context.get_udfs()[0]
+    expected_results = [
+        f"var_1_applied = var_0.apply(func={f.name}, axis=1, raw=True, result_type='expand')",
+        "var_1_applied.columns = ['A', 'B', 'C']",
+        "var_1 = var_1_applied.astype("
+        "{'A': np.dtype('int64'),"
+        " 'B': np.dtype('int64'),"
+        " 'C': np.dtype('int64')})",
+    ]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/misc/test_drop_duplicates.py

@@ -0,0 +1,92 @@
+# 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 pytest
+
+from ...... import dataframe as md
+from ....core import SPECodeContext
+from ...misc import DropDuplicatesOperatorAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        [
+            [1, 10, 101],
+            [9, 90, 909],
+            [2, 20, 202],
+        ],
+        index=pd.MultiIndex.from_arrays(
+            [[1, 9, 2], [11, 99, 22], [111, 999, 222]],
+            names=("idx_0", "idx_1", "idx_2"),
+        ),
+        columns=list("ABC"),
+    )
+
+
+@pytest.fixture
+def s1():
+    return md.Series([5, 2, 3, 1], index=[5, 2, 3, 1], name="A")
+
+
+@pytest.fixture
+def multi_index():
+    arrays = [
+        ["a1", "a2", "a3"],
+        ["b1", "b2", "b3"],
+        ["c1", "c2", "c3"],
+        ["d1", "d2", "d3"],
+        ["e1", "e2", "e3"],
+    ]
+    return md.Index(
+        pd.MultiIndex.from_arrays(
+            arrays, names=("idx_a", "idx_b", "idx_c", "idx_d", "idx_e")
+        )
+    )
+
+
+def test_dataframe_drop_duplicates(df1):
+    adapter = DropDuplicatesOperatorAdapter()
+    context = SPECodeContext()
+
+    df = df1.drop_duplicates(["A", "B"], keep=False)
+    results = adapter.generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.drop_duplicates(subset=['A', 'B'], keep=False, "
+        "ignore_index=False)"
+    ]
+    assert results == expected_results
+
+
+def test_series_drop_duplicates(s1):
+    adapter = DropDuplicatesOperatorAdapter()
+    context = SPECodeContext()
+
+    s = s1.drop_duplicates(keep="first")
+    results = adapter.generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.drop_duplicates(keep='first', ignore_index=False)"
+    ]
+    assert results == expected_results
+
+
+def test_index_drop_duplicates(multi_index):
+    adapter = DropDuplicatesOperatorAdapter()
+    context = SPECodeContext()
+
+    df = multi_index.drop_duplicates(keep="first")
+    results = adapter.generate_code(df.op, context)
+    expected_results = ["var_1 = var_0.drop_duplicates(keep='first')"]
+    assert results == expected_results

maxframe/codegen/spe/dataframe/tests/misc/test_misc.py

@@ -0,0 +1,234 @@
+# 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 numpy as np
+import pandas as pd
+import pytest
+
+from ...... import dataframe as md
+from ....core import SPECodeContext
+from ...misc import (
+    CaseWhenOperatorAdapter,
+    DataFrameAstypeAdapter,
+    DataFrameCheckMonotonicAdapter,
+    DataFrameCutAdapter,
+    DataFrameDescribeAdapter,
+    DataFrameDiffAdapter,
+    DataFrameDropAdapter,
+    DataFrameDuplicatedAdapter,
+    DataFrameExplodeAdapter,
+    DataFrameIsinAdapter,
+    DataFrameMapAdapter,
+    DataFrameMeltAdapter,
+    DataFrameMemoryUsageAdapter,
+    DataFramePivotTableAdapter,
+    DataFrameShiftAdapter,
+    DataFrameStackAdapter,
+    DataFrameToNumericAdapter,
+)
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        np.random.randn(6, 4),
+        index=md.Index(["1", "2", "3", "4", "5", "6"], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+@pytest.fixture
+def midx_df1():
+    return md.DataFrame(
+        [
+            [1, 10, 101],
+            [9, 90, 909],
+            [2, 20, 202],
+        ],
+        index=pd.MultiIndex.from_arrays(
+            [[1, 9, 2], [11, 99, 22], [111, 999, 222]],
+            names=("idx_0", "idx_1", "idx_2"),
+        ),
+        columns=list("ABC"),
+    )
+
+
+def test_astype(df1):
+    v1 = df1.astype({"A": "string"})
+    context = SPECodeContext()
+    results = DataFrameAstypeAdapter().generate_code(v1.op, context)
+    assert results[0] == "var_1 = var_0.astype({'A': 'string'})"
+
+
+def test_case_when(df1):
+    s = df1.A.case_when([(df1.B > 50, df1.A + 10), (df1.C < 500, 3)])
+    context = SPECodeContext()
+    results = CaseWhenOperatorAdapter().generate_code(s.op, context)
+    expected_results = [
+        "var_1 = var_0.case_when(caselist=[(var_2, var_4), (var_3, 3)])"
+    ]
+    assert results == expected_results
+
+
+def test_check_monotonic():
+    context = SPECodeContext()
+
+    v0 = md.Series([1, 2, 3, 4, 5, 6])
+    v1 = v0.is_monotonic_increasing
+    results = DataFrameCheckMonotonicAdapter().generate_code(v1.op, context)
+    assert results[0] == "var_1 = var_0.is_monotonic_increasing"
+
+    v2 = v0.is_monotonic_decreasing
+    results = DataFrameCheckMonotonicAdapter().generate_code(v2.op, context)
+    assert results[0] == "var_2 = var_0.is_monotonic_decreasing"
+
+
+def test_cut():
+    context = SPECodeContext()
+
+    v0 = md.Series([1, 2, 3, 4, 5, 6])
+    v1 = md.cut(v0, 3)
+    results = DataFrameCutAdapter().generate_code(v1.op, context)
+    assert results[0] == (
+        "var_0 = pd.cut(var_1, 3, skip_none=None, right=True, labels=None, "
+        "retbins=False, precision=3, include_lowest=False, duplicates='raise', "
+        "ordered=True)"
+    )
+
+
+def test_describe(df1):
+    df = df1.describe(include="all")
+    context = SPECodeContext()
+    results = DataFrameDescribeAdapter().generate_code(df.op, context)
+    assert (
+        results[0]
+        == "var_1 = var_0.describe(percentiles=[0.25, 0.5, 0.75], include='all')"
+    )
+
+
+def test_diff(df1):
+    df = df1.diff(periods=1)
+    context = SPECodeContext()
+    results = DataFrameDiffAdapter().generate_code(df.op, context)
+    assert results[0] == "var_1 = var_0.diff(periods=1, axis=0)"
+
+
+def test_drop(midx_df1):
+    df = midx_df1.drop(index=(1, 11, 111), columns=["A", "C"], errors="ignore")
+    adapter = DataFrameDropAdapter()
+    context = SPECodeContext()
+    results = adapter.generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.drop(index=(1, 11, 111), columns=['A', 'C'], level=None,"
+        " errors='ignore')"
+    ]
+    assert results == expected_results
+
+    del midx_df1["A"]
+    results = adapter.generate_code(midx_df1.op, context)
+    expected_results = [
+        "var_2 = var_0.drop(index=None, columns='A', level=None, errors='raise')"
+    ]
+    assert results == expected_results
+
+
+def test_duplicated(df1):
+    df = df1.duplicated(subset=["A", "B"], keep=False)
+    context = SPECodeContext()
+    results = DataFrameDuplicatedAdapter().generate_code(df.op, context)
+    assert results[0] == "var_1 = var_0.duplicated(subset=['A', 'B'], keep=False)"
+
+
+def test_explode():
+    context = SPECodeContext()
+
+    v0 = md.Series([[1, 2, 3], [5, 6]])
+    v1 = v0.explode(ignore_index=True)
+    results = DataFrameExplodeAdapter().generate_code(v1.op, context)
+    assert results[0] == "var_1 = var_0.explode(None, ignore_index=True)"
+
+
+def test_isin(df1):
+    filter_dict = {"A": [0, 1], "B": [2, 3], "E": [99, 100]}
+    df = df1.isin(filter_dict)
+    context = SPECodeContext()
+    results = DataFrameIsinAdapter().generate_code(df.op, context)
+    expected_results = [
+        "var_1 = var_0.isin({'A': [0, 1], 'B': [2, 3], 'E': [99, 100]})"
+    ]
+    assert results == expected_results
+
+
+def test_map(df1):
+    v0 = md.Series([1, 2, 3, 4, 5, 6])
+    v1 = v0.map(lambda x: x * 2 + 1, dtype="int64")
+    context = SPECodeContext()
+    results = DataFrameMapAdapter().generate_code(v1.op, context)
+    assert len(context.get_udfs()) == 1
+    f = context.get_udfs()[0]
+    expected_results = [f"var_1 = var_0.map({f.name})"]
+    assert results == expected_results
+
+
+def test_melt(df1):
+    context = SPECodeContext()
+
+    v1 = df1.melt(id_vars=["A"], value_vars=["B"])
+    results = DataFrameMeltAdapter().generate_code(v1.op, context)
+    assert (
+        results[0]
+        == "var_1 = var_0.melt(id_vars=['A'], value_vars=['B'], value_name='value')"
+    )
+
+
+def test_memory_usage(df1):
+    context = SPECodeContext()
+    v1 = df1.memory_usage(index=False)
+    results = DataFrameMemoryUsageAdapter().generate_code(v1.op, context)
+    assert results[0] == "var_1 = var_0.memory_usage(index=False, deep=False)"
+
+
+def test_pivot_table(midx_df1):
+    df = midx_df1.pivot_table(columns="B", values="C")
+    context = SPECodeContext()
+    results = DataFramePivotTableAdapter().generate_code(df.op, context)
+    assert results[0] == (
+        "var_1 = var_0.pivot_table(values='C', columns='B', "
+        "aggfunc='mean', margins=False, dropna=True, margins_name='All', "
+        "sort=True)"
+    )
+
+
+def test_shift(df1):
+    df = df1.shift(periods=1)
+    context = SPECodeContext()
+    results = DataFrameShiftAdapter().generate_code(df.op, context)
+    assert results[0] == "var_1 = var_0.shift(periods=1, axis=0)"
+
+
+def test_stack(midx_df1):
+    df = midx_df1.stack([0])
+    context = SPECodeContext()
+    results = DataFrameStackAdapter().generate_code(df.op, context)
+    assert results[0] == "var_1 = var_0.stack(level=[0], dropna=True)"
+
+
+def test_to_numeric():
+    v0 = md.Series([1, 2, 3, 4, 5, 6])
+    v1 = md.to_numeric(v0, downcast="float")
+    context = SPECodeContext()
+    results = DataFrameToNumericAdapter().generate_code(v1.op, context)
+    assert (
+        results[0] == "var_1 = pd.to_numeric(var_0, errors='raise', downcast='float')"
+    )

maxframe/codegen/spe/dataframe/tests/missing/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 1999-2025 Alibaba Group Holding Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

maxframe/codegen/spe/dataframe/tests/missing/test_checkna.py

@@ -0,0 +1,94 @@
+# 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 numpy as np
+import pandas as pd
+import pytest
+
+from ...... import dataframe as md
+from .....core import EngineAcceptance
+from ....core import SPECodeContext
+from ....dataframe.missing import DataFrameCheckNAAdapter
+
+
+@pytest.fixture
+def df1():
+    return md.DataFrame(
+        [
+            [1, 2, np.Inf, pd.NA],
+            [4, 5, np.NaN, pd.NaT],
+            [3, None, None, "3000"],
+            [4, None, True, None],
+        ],
+        index=md.Index([1, 2, 3, 4], name="test_idx"),
+        columns=list("ABCD"),
+    )
+
+
+@pytest.fixture
+def ds1():
+    return md.Series(pd.Series((1, 2, 3, None, None, None, None)))
+
+
+@pytest.fixture
+def index1():
+    return md.Index(pd.Index([1, 2, None, 4]))
+
+
+@pytest.mark.parametrize(
+    "check_func, expected_condition",
+    [("isna", "isna"), ("isnull", "isna"), ("notna", "notna"), ("notnull", "notna")],
+)
+def test_seires(ds1, check_func, expected_condition):
+    adapter = DataFrameCheckNAAdapter()
+    context = SPECodeContext()
+    func = getattr(ds1, check_func)
+    ds = func()
+    assert adapter.accepts(ds.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(ds.op, context)
+    expected_results = [f"var_1 = var_0.{expected_condition}()"]
+    assert results == expected_results
+
+
+@pytest.mark.parametrize(
+    "check_func, expected_condition",
+    [("isna", "isna"), ("isnull", "isna"), ("notna", "notna"), ("notnull", "notna")],
+)
+def test_maxframe(df1, check_func, expected_condition):
+    adapter = DataFrameCheckNAAdapter()
+    context = SPECodeContext()
+    func = getattr(df1, check_func)
+    df = func()
+    assert adapter.accepts(df.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(df.op, context)
+    expected_results = [f"var_1 = var_0.{expected_condition}()"]
+    assert results == expected_results
+
+
+@pytest.mark.parametrize(
+    "check_func, expected_condition",
+    [
+        ("isna", "isna"),
+        ("notna", "notna"),
+    ],
+)
+def test_index_isna(index1, check_func, expected_condition):
+    adapter = DataFrameCheckNAAdapter()
+    context = SPECodeContext()
+    func = getattr(index1, check_func)
+    di = func()
+    assert adapter.accepts(di.op) == EngineAcceptance.ACCEPT
+    results = adapter.generate_code(di.op, context)
+    expected_results = [f"var_1 = var_0.{expected_condition}()"]
+    assert results == expected_results