maxframe 1.3.0__cp38-cp38-win_amd64.whl → 2.0.0__cp38-cp38-win_amd64.whl

maxframe/dataframe/groupby/core.py

@@ -13,14 +13,15 @@
 # limitations under the License.
 
 from collections import namedtuple
+from typing import List
 
 import pandas as pd
 
 from ... import opcodes
-from ...core import ENTITY_TYPE, Entity, OutputType
+from ...core import ENTITY_TYPE, Entity, EntityData, OutputType
 from ...core.operator import MapReduceOperator
 from ...serialization.serializables import AnyField, BoolField, Int32Field
-from ...utils import lazy_import, no_default, pd_release_version
+from ...utils import lazy_import, no_default
 from ..core import SERIES_TYPE
 from ..initializer import Series as asseries
 from ..operators import DataFrameOperatorMixin
@@ -28,15 +29,13 @@ from ..utils import build_df, build_series, parse_index
 
 cudf = lazy_import("cudf")
 
-_GROUP_KEYS_NO_DEFAULT = pd_release_version[:2] == (1, 5)
-_default_group_keys = no_default if _GROUP_KEYS_NO_DEFAULT else True
-
 
 NamedAgg = namedtuple("NamedAgg", ["column", "aggfunc"])
 
 
-class DataFrameGroupByOperator(MapReduceOperator, DataFrameOperatorMixin):
+class DataFrameGroupByOp(MapReduceOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.GROUPBY
+    _legacy_name = "DataFrameGroupByOperator"
 
     by = AnyField(
         "by",
@@ -96,8 +95,6 @@ class DataFrameGroupByOperator(MapReduceOperator, DataFrameOperatorMixin):
 
         new_kw = self.groupby_params
         new_kw.update(kwargs)
-        if new_kw.get("level"):
-            new_kw["level"] = 0
         if isinstance(new_kw["by"], list):
             new_by = []
             for v in new_kw["by"]:
@@ -115,17 +112,18 @@ class DataFrameGroupByOperator(MapReduceOperator, DataFrameOperatorMixin):
             new_kw["by"] = new_by
         return mock_obj.groupby(**new_kw)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs[1:])
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameGroupByOp", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs[1:])
         if len(inputs) > 1:
             by = []
-            for k in self.by:
+            for k in op.by:
                 if isinstance(k, SERIES_TYPE):
                     by.append(next(inputs_iter))
                 else:
                     by.append(k)
-            self.by = by
+            op.by = by
 
     def __call__(self, df):
         params = df.params.copy()
@@ -153,9 +151,74 @@ class DataFrameGroupByOperator(MapReduceOperator, DataFrameOperatorMixin):
         return self.new_tileable(inputs, **params)
 
 
-def groupby(
-    df, by=None, level=None, as_index=True, sort=True, group_keys=_default_group_keys
-):
+DataFrameGroupByOperator = DataFrameGroupByOp
+
+
+def groupby(df, by=None, level=None, as_index=True, sort=True, group_keys=True):
+    """
+    Group DataFrame using a mapper or by a Series of columns.
+
+    A groupby operation involves some combination of splitting the
+    object, applying a function, and combining the results. This can be
+    used to group large amounts of data and compute operations on these
+    groups.
+
+    Parameters
+    ----------
+    by : mapping, function, label, or list of labels
+        Used to determine the groups for the groupby.
+        If ``by`` is a function, it's called on each value of the object's
+        index. If a dict or Series is passed, the Series or dict VALUES
+        will be used to determine the groups (the Series' values are first
+        aligned; see ``.align()`` method). If an ndarray is passed, the
+        values are used as-is to determine the groups. A label or list of
+        labels may be passed to group by the columns in ``self``. Notice
+        that a tuple is interpreted as a (single) key.
+    as_index : bool, default True
+        For aggregated output, return object with group labels as the
+        index. Only relevant for DataFrame input. as_index=False is
+        effectively "SQL-style" grouped output.
+    sort : bool, default True
+        Sort group keys. Get better performance by turning this off.
+        Note this does not influence the order of observations within each
+        group. Groupby preserves the order of rows within each group.
+    group_keys : bool
+        When calling apply, add group keys to index to identify pieces.
+
+    Notes
+    -----
+    MaxFrame only supports groupby with axis=0.
+    Default value of `group_keys` will be decided given the version of local
+    pandas library, which is True since pandas 2.0.
+
+    Returns
+    -------
+    DataFrameGroupBy
+        Returns a groupby object that contains information about the groups.
+
+    See Also
+    --------
+    resample : Convenience method for frequency conversion and resampling
+        of time series.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'Animal': ['Falcon', 'Falcon',
+    ...                               'Parrot', 'Parrot'],
+    ...                    'Max Speed': [380., 370., 24., 26.]})
+    >>> df.execute()
+       Animal  Max Speed
+    0  Falcon      380.0
+    1  Falcon      370.0
+    2  Parrot       24.0
+    3  Parrot       26.0
+    >>> df.groupby(['Animal']).mean().execute()
+            Max Speed
+    Animal
+    Falcon      375.0
+    Parrot       25.0
+    """
     if not as_index and df.op.output_types[0] == OutputType.series:
         raise TypeError("as_index=False only valid with DataFrame")
 
@@ -168,7 +231,7 @@ def groupby(
         by = [by]
     elif df.ndim > 1 and by is not None and not isinstance(by, list):
         by = [by]
-    op = DataFrameGroupByOperator(
+    op = DataFrameGroupByOp(
         by=by,
         level=level,
         as_index=as_index,

maxframe/dataframe/groupby/extensions.py

@@ -0,0 +1,26 @@
+# 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 ...core import BaseMaxFrameAccessor
+from ..core import DataFrameGroupBy, SeriesGroupBy
+
+
+class DataFrameGroupByMaxFrameAccessor(BaseMaxFrameAccessor):
+    obj: "DataFrameGroupBy"
+    _api_count: int = 0
+
+
+class SeriesGroupByMaxFrameAccessor(BaseMaxFrameAccessor):
+    obj: "SeriesGroupBy"
+    _api_count: int = 0

maxframe/dataframe/groupby/fill.py

@@ -21,8 +21,9 @@ from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import parse_index
 
 
-class GroupByFillOperator(DataFrameOperator, DataFrameOperatorMixin):
+class GroupByFill(DataFrameOperator, DataFrameOperatorMixin):
     _op_module_ = "dataframe.groupby"
+    _legacy_name = "GroupByFillOperator"
 
     value = AnyField("value", default=None)
     method = StringField("method", default=None)
@@ -77,21 +78,25 @@ class GroupByFillOperator(DataFrameOperator, DataFrameOperatorMixin):
         return self.new_tileable([groupby], **kw)
 
 
-class GroupByFFill(GroupByFillOperator):
+class GroupByFFill(GroupByFill):
     _op_type_ = opcodes.FILL_NA
     _func_name = "ffill"
 
 
-class GroupByBFill(GroupByFillOperator):
+class GroupByBFill(GroupByFill):
     _op_type = opcodes.FILL_NA
     _func_name = "bfill"
 
 
-class GroupByFillNa(GroupByFillOperator):
+class GroupByFillNa(GroupByFill):
     _op_type = opcodes.FILL_NA
     _func_name = "fillna"
 
 
+# keep for import compatibility
+GroupByFillOperator = GroupByFill
+
+
 def ffill(groupby, limit=None):
     """
     Forward fill the values.

maxframe/dataframe/groupby/sample.py

@@ -13,13 +13,13 @@
 # limitations under the License.
 
 import copy
-from typing import Optional, Sequence, Union
+from typing import List, Optional, Sequence, Union
 
 import numpy as np
 import pandas as pd
 
 from ... import opcodes
-from ...core import ENTITY_TYPE, OutputType, get_output_types
+from ...core import ENTITY_TYPE, EntityData, OutputType, get_output_types
 from ...serialization.serializables import (
     BoolField,
     DictField,
@@ -48,7 +48,6 @@ class GroupBySample(DataFrameOperator, DataFrameOperatorMixin):
     seed = Int32Field("seed", default=None)
     _random_state = RandomStateField("random_state", default=None)
     errors = StringField("errors", default=None)
-
     # for chunks
     # num of instances for chunks
     input_nsplits = NDArrayField("input_nsplits", default=None)
@@ -60,12 +59,13 @@ class GroupBySample(DataFrameOperator, DataFrameOperatorMixin):
     def random_state(self):
         return self._random_state
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
+    @classmethod
+    def _set_inputs(cls, op: "GroupBySample", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
         input_iter = iter(inputs)
         next(input_iter)
-        if isinstance(self.weights, ENTITY_TYPE):
-            self.weights = next(input_iter)
+        if isinstance(op.weights, ENTITY_TYPE):
+            op.weights = next(input_iter)
 
     def __call__(self, groupby):
         df = groupby

maxframe/dataframe/groupby/tests/test_groupby.py

@@ -23,7 +23,7 @@ from .... import opcodes
 from ....core import OutputType
 from ...core import DataFrame, DataFrameGroupBy, SeriesGroupBy
 from ..aggregation import DataFrameGroupByAgg
-from ..core import DataFrameGroupByOperator
+from ..core import DataFrameGroupByOp
 from ..getitem import GroupByIndex
 
 
@@ -39,7 +39,7 @@ def test_groupby():
 
     grouped = mdf.groupby("b")
     assert isinstance(grouped, DataFrameGroupBy)
-    assert isinstance(grouped.op, DataFrameGroupByOperator)
+    assert isinstance(grouped.op, DataFrameGroupByOp)
     assert list(grouped.key_dtypes.index) == ["b"]
 
     series = pd.Series([3, 4, 5, 3, 5, 4, 1, 2, 3])
@@ -47,7 +47,7 @@ def test_groupby():
     grouped = ms.groupby(lambda x: x + 1)
 
     assert isinstance(grouped, SeriesGroupBy)
-    assert isinstance(grouped.op, DataFrameGroupByOperator)
+    assert isinstance(grouped.op, DataFrameGroupByOp)
 
     with pytest.raises(TypeError):
         ms.groupby(lambda x: x + 1, as_index=False)

maxframe/dataframe/groupby/transform.py

@@ -12,19 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import logging
+from typing import MutableMapping, Union
 
 import numpy as np
-import pandas as pd
 
 from ... import opcodes
 from ...core import OutputType
 from ...serialization.serializables import AnyField, BoolField, DictField, TupleField
-from ...utils import quiet_stdio
+from ...udf import BuiltinFunction, MarkedFunction
+from ...utils import copy_if_possible
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
-from ..utils import copy_func_scheduling_hints, parse_index
-
-logger = logging.getLogger(__name__)
+from ..utils import (
+    InferredDataFrameMeta,
+    copy_func_scheduling_hints,
+    infer_dataframe_return_value,
+    parse_index,
+)
 
 
 class GroupByTransform(DataFrameOperator, DataFrameOperatorMixin):
@@ -42,68 +45,61 @@ class GroupByTransform(DataFrameOperator, DataFrameOperatorMixin):
         if hasattr(self, "func"):
             copy_func_scheduling_hints(self.func, self)
 
-    def _infer_df_func_returns(self, in_groupby, dtypes, index):
-        index_value, output_types, new_dtypes = None, None, None
-
-        output_types = (
-            [OutputType.dataframe]
-            if in_groupby.op.output_types[0] == OutputType.dataframe_groupby
-            else [OutputType.series]
-        )
-
-        try:
-            mock_groupby = in_groupby.op.build_mock_groupby()
-            with np.errstate(all="ignore"), quiet_stdio():
-                if self.call_agg:
-                    infer_df = mock_groupby.agg(self.func, *self.args, **self.kwds)
-                else:
-                    infer_df = mock_groupby.transform(
-                        self.func, *self.args, **self.kwds
-                    )
-
-            # todo return proper index when sort=True is implemented
-            index_value = parse_index(None, in_groupby.key, self.func)
-
-            if isinstance(infer_df, pd.DataFrame):
-                output_types = [OutputType.dataframe]
-                new_dtypes = new_dtypes or infer_df.dtypes
+    def has_custom_code(self) -> bool:
+        return not isinstance(self.func, BuiltinFunction)
+
+    def _infer_df_func_returns(
+        self, in_groupby, dtypes, dtype=None, name=None, index=None
+    ) -> InferredDataFrameMeta:
+        def infer_func(groupby_obj):
+            args = copy_if_possible(self.args)
+            kwds = copy_if_possible(self.kwds)
+            if self.call_agg:
+                return groupby_obj.agg(self.func, *args, **kwds)
             else:
-                output_types = [OutputType.series]
-                new_dtypes = new_dtypes or (infer_df.name, infer_df.dtype)
-        except:  # noqa: E722  # nosec
-            logger.info("Exception raised while inferring df_func", exc_info=True)
+                return groupby_obj.transform(self.func, *args, **kwds)
 
-        self.output_types = output_types if not self.output_types else self.output_types
-        dtypes = new_dtypes if dtypes is None else dtypes
-        index_value = index_value if index is None else parse_index(index)
-        return dtypes, index_value
+        if self.call_agg:
+            output_type = None
+        elif in_groupby.op.output_types[0] == OutputType.dataframe_groupby:
+            output_type = OutputType.dataframe
+        else:
+            output_type = OutputType.series
+
+        inferred_meta = infer_dataframe_return_value(
+            in_groupby,
+            infer_func,
+            output_type=output_type,
+            dtypes=dtypes,
+            dtype=dtype,
+            name=name,
+            index=index,
+        )
+        if inferred_meta.output_type and not self.output_types:
+            self.output_types = [inferred_meta.output_type]
+        return inferred_meta
 
     def __call__(
         self, groupby, dtypes=None, dtype=None, name=None, index=None, skip_infer=None
     ):
         in_df = groupby.inputs[0]
 
-        if dtypes is None and dtype is not None:
-            dtypes = (name, dtype)
         if skip_infer:
-            dtypes, index_value = None, None
+            dtypes, dtype, name, index_value = None, None, None, None
             self.output_types = (
                 [OutputType.dataframe]
                 if groupby.op.output_types[0] == OutputType.dataframe_groupby
                 else [OutputType.series]
             )
         else:
-            dtypes, index_value = self._infer_df_func_returns(groupby, dtypes, index)
-            for arg, desc in zip(
-                (self.output_types, dtypes), ("output_types", "dtypes")
-            ):
-                if arg is None:
-                    raise TypeError(
-                        f"Cannot determine {desc} by calculating with enumerate data, "
-                        "please specify it as arguments"
-                    )
-        if index_value is None:
-            index_value = parse_index(None, (in_df.key, in_df.index_value.key))
+            inferred_meta = self._infer_df_func_returns(
+                groupby, dtypes=dtypes, dtype=dtype, name=name, index=index
+            )
+            inferred_meta.check_absence("output_type", "dtypes", "dtype")
+            dtypes = inferred_meta.dtypes
+            dtype = inferred_meta.dtype
+            name = inferred_meta.name
+            index_value = inferred_meta.index_value
 
         if self.output_types[0] == OutputType.dataframe:
             new_shape = (
@@ -123,7 +119,6 @@ class GroupByTransform(DataFrameOperator, DataFrameOperatorMixin):
                 columns_value=columns_value,
             )
         else:
-            name, dtype = dtypes
             new_shape = (np.nan,) if self.call_agg else groupby.shape
             return self.new_series(
                 [groupby],
@@ -133,6 +128,14 @@ class GroupByTransform(DataFrameOperator, DataFrameOperatorMixin):
                 index_value=index_value,
             )
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "GroupByTransform"
+    ) -> None:
+        if isinstance(op.func, MarkedFunction):
+            ctx[op.outputs[0].key] = float("inf")
+        super().estimate_size(ctx, op)
+
 
 def groupby_transform(
     groupby,

maxframe/dataframe/indexing/align.py

@@ -12,12 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Optional, Union
+from typing import Any, List, Optional, Union
 
 import numpy as np
 
 from ... import opcodes
-from ...core import OutputType, get_output_types
+from ...core import EntityData, OutputType, get_output_types
 from ...serialization.serializables import (
     AnyField,
     Int16Field,
@@ -53,10 +53,11 @@ class DataFrameAlign(DataFrameOperator, DataFrameOperatorMixin):
     def output_limit(self) -> int:
         return 2
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self.lhs = inputs[0]
-        self.rhs = inputs[1]
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameAlign", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.lhs = inputs[0]
+        op.rhs = inputs[1]
 
     def __call__(self, lhs: TileableType, rhs: TileableType):
         if self.broadcast_axis != 1 or lhs.ndim == rhs.ndim:

maxframe/dataframe/indexing/getitem.py

@@ -13,12 +13,13 @@
 # limitations under the License.
 
 from numbers import Integral
+from typing import List
 
 import numpy as np
 import pandas as pd
 
 from ... import opcodes
-from ...core import ENTITY_TYPE, OutputType
+from ...core import ENTITY_TYPE, EntityData, OutputType
 from ...serialization.serializables import AnyField, BoolField
 from ...tensor.core import TENSOR_TYPE
 from ...tensor.datasource import tensor as astensor
@@ -66,7 +67,6 @@ class DataFrameIndex(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.INDEX
 
     col_names = AnyField("col_names", default=None)
-
     # for bool index
     mask = AnyField("mask", default=None)
     identical_index = BoolField("identical_index")
@@ -75,12 +75,13 @@ class DataFrameIndex(DataFrameOperator, DataFrameOperatorMixin):
         output_types = output_types or [OutputType.series]
         super().__init__(_output_types=output_types, **kw)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        if isinstance(self.col_names, ENTITY_TYPE):
-            self.col_names = self._inputs[0]
-        if isinstance(self.mask, ENTITY_TYPE):
-            self.mask = self._inputs[-1]
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameIndex", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if isinstance(op.col_names, ENTITY_TYPE):
+            op.col_names = op._inputs[0]
+        if isinstance(op.mask, ENTITY_TYPE):
+            op.mask = op._inputs[-1]
 
     def __call__(self, df):
         if self.col_names is not None:

maxframe/dataframe/indexing/iloc.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from numbers import Integral
+from typing import List
 
 import numpy as np
 import pandas as pd
@@ -21,7 +22,7 @@ from pandas.core.indexing import IndexingError
 
 from ... import opcodes
 from ...config import options
-from ...core import ENTITY_TYPE, OutputType
+from ...core import ENTITY_TYPE, EntityData, OutputType
 from ...serialization.serializables import AnyField, KeyField, ListField
 from ...tensor import asarray
 from ...tensor.indexing.core import calc_shape
@@ -181,26 +182,29 @@ class DataFrameIlocGetItem(DataFrameOperator, HeadTailOptimizedOperatorMixin):
     _input = KeyField("input")
     indexes = ListField("indexes", default=None)
 
-    def __init__(self, gpu=None, sparse=False, output_types=None, **kw):
-        super().__init__(gpu=gpu, sparse=sparse, _output_types=output_types, **kw)
+    def __init__(self, gpu=None, sparse=False, **kw):
+        if kw.get("output_types"):
+            kw["_output_types"] = kw.pop("output_types")
+        super().__init__(gpu=gpu, sparse=sparse, **kw)
         if not self.output_types:
-            self.output_types = [OutputType.dataframe]
+            self._output_types = [OutputType.dataframe]
 
     @property
     def input(self):
         return self._input
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs)
-        self._input = next(inputs_iter)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameIlocGetItem", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs)
+        op._input = next(inputs_iter)
         indexes = []
-        for index in self.indexes:
+        for index in op.indexes:
             if isinstance(index, ENTITY_TYPE):
                 indexes.append(next(inputs_iter))
             else:
                 indexes.append(index)
-        self.indexes = indexes
+        op.indexes = indexes
 
     def __call__(self, df):
         # Note [Fancy Index of Numpy and Pandas]
@@ -222,7 +226,6 @@ class DataFrameIlocGetItem(DataFrameOperator, HeadTailOptimizedOperatorMixin):
         inputs = [df] + [
             index for index in self.indexes if isinstance(index, ENTITY_TYPE)
         ]
-
         # NB: pandas only compresses the result to series when index on one of axis is integral
         if isinstance(self.indexes[1], Integral):
             shape = shape0
@@ -274,19 +277,20 @@ class SeriesIlocGetItem(DataFrameOperator, HeadTailOptimizedOperatorMixin):
     def input(self):
         return self._input
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
+    @classmethod
+    def _set_inputs(cls, op: "SeriesIlocGetItem", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
 
-        inputs_iter = iter(self._inputs)
-        self._input = next(inputs_iter)
+        inputs_iter = iter(op._inputs)
+        op._input = next(inputs_iter)
 
         indexes = []
-        for index in self.indexes:
+        for index in op.indexes:
             if isinstance(index, ENTITY_TYPE):
                 indexes.append(next(inputs_iter))
             else:
                 indexes.append(index)
-        self.indexes = indexes
+        op.indexes = indexes
 
     def __call__(self, series):
         if isinstance(self.indexes[0], Integral):
@@ -322,19 +326,20 @@ class IndexIlocGetItem(DataFrameOperator, DataFrameOperatorMixin):
     def input(self):
         return self._input
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
+    @classmethod
+    def _set_inputs(cls, op: "IndexIlocGetItem", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
 
-        inputs_iter = iter(self._inputs)
-        self._input = next(inputs_iter)
+        inputs_iter = iter(op._inputs)
+        op._input = next(inputs_iter)
 
         indexes = []
-        for index in self.indexes:
+        for index in op.indexes:
             if isinstance(index, ENTITY_TYPE):
                 indexes.append(next(inputs_iter))
             else:
                 indexes.append(index)
-        self.indexes = indexes
+        op.indexes = indexes
 
     def __call__(self, idx):
         if isinstance(self.indexes[0], Integral):

maxframe/dataframe/indexing/insert.py

@@ -12,9 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import List
+
 import pandas as pd
 
 from ... import opcodes
+from ...core import EntityData
 from ...serialization.serializables import AnyField, BoolField, Int64Field
 from ...tensor.core import TENSOR_TYPE
 from ..core import SERIES_TYPE
@@ -30,10 +33,11 @@ class DataFrameInsert(DataFrameOperator, DataFrameOperatorMixin):
     value = AnyField("value")
     allow_duplicates = BoolField("allow_duplicates")
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameInsert", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
         if len(inputs) > 1:
-            self._value = self._inputs[-1]
+            op._value = op._inputs[-1]
 
     def __call__(self, df):
         inputs = [df]