maxframe 1.3.0__cp38-cp38-win32.whl → 2.0.0b1__cp38-cp38-win32.whl

maxframe/core/operator/shuffle.py

@@ -13,20 +13,14 @@
 # limitations under the License.
 
 from ... import opcodes
-from ...serialization.serializables import (
-    FieldTypes,
-    Int32Field,
-    StringField,
-    TupleField,
-)
-from . import FetchShuffle, ShuffleFetchType
+from ...serialization.serializables import Int32Field, StringField
 from .base import Operator, OperatorStage, VirtualOperator
+from .core import TileableOperatorMixin
 
 
-class ShuffleProxy(VirtualOperator):
+class ShuffleProxy(VirtualOperator, TileableOperatorMixin):
     _op_type_ = opcodes.SHUFFLE_PROXY
     n_mappers = Int32Field("n_mappers", default=0)
-    # `n_reducers` will be updated in `MapReduceOperator._new_chunks`
     n_reducers = Int32Field("n_reducers", default=0)
 
 
@@ -37,13 +31,11 @@ class MapReduceOperator(Operator):
     """
 
     # for reducer
-    reducer_index = TupleField("reducer_index", FieldTypes.uint64)
+    reducer_id = Int32Field("reducer_id")
     # Total reducer nums, which also be shuffle blocks for single mapper.
     n_reducers = Int32Field("n_reducers")
-    # The reducer ordinal in all reducers. It's different from reducer_index,
-    # which might be a tuple.
-    # `reducer_ordinal` will be set in `_new_chunks`.
-    reducer_ordinal = Int32Field("reducer_ordinal")
+    # preserved field to keep serialization compatible
+    _mr_preserved = Int32Field("mr_preserved")
     reducer_phase = StringField("reducer_phase", default=None)
 
     def __init__(self, *args, **kwargs):
@@ -51,61 +43,3 @@ class MapReduceOperator(Operator):
         if self.stage == OperatorStage.reduce:
             # for reducer, we assign worker at first
             self.scheduling_hint.reassign_worker = True
-
-    def get_dependent_data_keys(self):
-        from .fetch import FetchShuffle
-
-        if self.stage == OperatorStage.reduce:
-            inputs = self.inputs or ()
-            deps = []
-            for inp in inputs:
-                if isinstance(inp.op, ShuffleProxy):
-                    deps.extend(
-                        [(chunk.key, self.reducer_index) for chunk in inp.inputs or ()]
-                    )
-                elif isinstance(inp.op, FetchShuffle):
-                    # fetch shuffle by index doesn't store data keys, so it won't run into this function.
-                    assert inp.op.shuffle_fetch_type == ShuffleFetchType.FETCH_BY_KEY
-                    deps.extend([(k, self.reducer_index) for k in inp.op.source_keys])
-                else:
-                    deps.append(inp.key)
-            return deps
-        return super().get_dependent_data_keys()
-
-    def iter_mapper_keys(self, input_id=0):
-        # key is mapper chunk key, index is mapper chunk index.
-        input_chunk = self.inputs[input_id]
-        if isinstance(input_chunk.op, ShuffleProxy):
-            keys = [inp.key for inp in input_chunk.inputs]
-        else:
-            assert isinstance(input_chunk.op, FetchShuffle), input_chunk.op
-            if input_chunk.op.shuffle_fetch_type == ShuffleFetchType.FETCH_BY_INDEX:
-                # For fetch shuffle by index, all shuffle block of same reducers are
-                # identified by their index. chunk key are not needed any more.
-                # so just mock key here.
-                # keep this in sync with ray executor `execute_subtask`.
-                return list(range(input_chunk.op.n_mappers))
-            keys = input_chunk.op.source_keys
-        return keys
-
-    def iter_mapper_data(self, ctx, input_id=0, pop=False, skip_none=False):
-        for key in self.iter_mapper_keys(input_id):
-            try:
-                if pop:
-                    yield ctx.pop((key, self.reducer_index))
-                else:
-                    yield ctx[key, self.reducer_index]
-            except KeyError:
-                if not skip_none:  # pragma: no cover
-                    raise
-                if not pop:
-                    ctx[key, self.reducer_index] = None
-
-    def execute(self, ctx, op):
-        """The mapper stage must ensure all mapper blocks are inserted into ctx
-        and no blocks for some reducers are missing. This is needed by shuffle
-        fetch by index, which shuffle block are identified by the  index instead
-        of data keys. For operators implementation simplicity, we can sort the
-        `ctx` by key which are (chunk key, reducer index) tuple and relax the
-        insert order requirements.
-        """

maxframe/dataframe/__init__.py

@@ -46,6 +46,7 @@ from .misc.cut import cut
 from .misc.eval import maxframe_eval as eval  # pylint: disable=redefined-builtin
 from .misc.get_dummies import get_dummies
 from .misc.melt import melt
+from .misc.pivot import pivot
 from .misc.pivot_table import pivot_table
 from .misc.qcut import qcut
 from .misc.to_numeric import to_numeric

maxframe/dataframe/accessors/datetime_/core.py

@@ -12,10 +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 OutputType
+from ....core import EntityData, OutputType
 from ....serialization.serializables import (
     BoolField,
     DictField,
@@ -45,9 +47,10 @@ class SeriesDatetimeMethod(DataFrameOperator, DataFrameOperatorMixin):
     def input(self):
         return self._input
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self._input = self._inputs[0]
+    @classmethod
+    def _set_inputs(cls, op: "SeriesDatetimeMethod", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
 
     def __call__(self, inp):
         return datetime_method_to_handlers[self.method].call(self, inp)

maxframe/dataframe/accessors/string_/core.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import List
+
 import numpy as np
 import pandas as pd
 
 from .... import opcodes
-from ....core import OutputType
+from ....core import EntityData, OutputType
 from ....serialization.serializables import DictField, KeyField, StringField, TupleField
 from ....tensor import tensor as astensor
 from ....tensor.core import TENSOR_TYPE
@@ -43,12 +45,13 @@ class SeriesStringMethod(DataFrameOperator, DataFrameOperatorMixin):
     def input(self):
         return self._input
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self._input = self._inputs[0]
-        if len(self._inputs) == 2:
+    @classmethod
+    def _set_inputs(cls, op: "SeriesStringMethod", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op._input = op._inputs[0]
+        if len(op._inputs) == 2:
             # for method cat
-            self.method_kwargs["others"] = self._inputs[1]
+            op.method_kwargs["others"] = op._inputs[1]
 
     def __call__(self, inp):
         return string_method_to_handlers[self.method].call(self, inp)

maxframe/dataframe/arithmetic/core.py

@@ -13,14 +13,15 @@
 # limitations under the License.
 
 import copy
+from typing import List, MutableMapping, Union
 
 import numpy as np
 import pandas as pd
 
-from ...core import ENTITY_TYPE
+from ...core import ENTITY_TYPE, EntityData
 from ...serialization.serializables import AnyField
 from ...tensor.core import TENSOR_TYPE
-from ...utils import classproperty, get_dtype
+from ...utils import classproperty, make_dtype
 from ..core import DATAFRAME_TYPE, SERIES_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..ufunc.tensor import TensorUfuncMixin
@@ -30,6 +31,7 @@ from ..utils import (
     infer_dtypes,
     infer_index_value,
     parse_index,
+    validate_axis,
 )
 
 
@@ -63,7 +65,7 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
             x2 is None or pd.api.types.is_scalar(x2) or isinstance(x2, TENSOR_TYPE)
         ):
             x2_dtype = x2.dtype if hasattr(x2, "dtype") else type(x2)
-            x2_dtype = get_dtype(x2_dtype)
+            x2_dtype = make_dtype(x2_dtype)
             if hasattr(cls, "return_dtype"):
                 dtype = cls.return_dtype
             else:
@@ -153,7 +155,7 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
                 columns = x1.columns_value
                 dtypes = x1.dtypes
                 index_shape, index = np.nan, None
-                if x1.index_value is not None and x1.index_value is not None:
+                if x1.index_value is not None and x2.index_value is not None:
                     if x1.index_value.key == x2.index_value.key:
                         dtypes = pd.Series(
                             [
@@ -277,34 +279,42 @@ class DataFrameBinOpMixin(DataFrameOperatorMixin):
             raise NotImplementedError
         return self._call(x2, x1)
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameOperator"
+    ):
+        ctx[op.outputs[0].key] = max(ctx[inp.key] for inp in (op.inputs or ()))
+
 
-class DataFrameBinOp(DataFrameOperator, DataFrameBinOpMixin):
+class DataFrameBinOp(DataFrameBinOpMixin, DataFrameOperator):
     axis = AnyField("axis", default=None)
     level = AnyField("level", default=None)
     fill_value = AnyField("fill_value", default=None)
     lhs = AnyField("lhs")
     rhs = AnyField("rhs")
 
-    def __init__(self, output_types=None, **kw):
-        super().__init__(_output_types=output_types, **kw)
+    def __init__(self, output_types=None, axis=0, **kw):
+        axis = validate_axis(axis)
+        super().__init__(_output_types=output_types, axis=axis, **kw)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        if len(self._inputs) == 2:
-            self.lhs = self._inputs[0]
-            self.rhs = self._inputs[1]
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameBinOp", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        if len(op._inputs) == 2:
+            op.lhs = op._inputs[0]
+            op.rhs = op._inputs[1]
         else:
-            if isinstance(self.lhs, ENTITY_TYPE):
-                self.lhs = self._inputs[0]
-            elif pd.api.types.is_scalar(self.lhs):
-                self.rhs = self._inputs[0]
+            if isinstance(op.lhs, ENTITY_TYPE):
+                op.lhs = op._inputs[0]
+            elif isinstance(op.rhs, ENTITY_TYPE):
+                op.rhs = op._inputs[0]
 
 
 class DataFrameUnaryOpMixin(DataFrameOperatorMixin):
     __slots__ = ()
 
 
-class DataFrameUnaryOp(DataFrameOperator, DataFrameUnaryOpMixin):
+class DataFrameUnaryOp(DataFrameUnaryOpMixin, DataFrameOperator):
     def __init__(self, output_types=None, **kw):
         super().__init__(_output_types=output_types, **kw)
 
@@ -337,9 +347,10 @@ class DataFrameUnaryOp(DataFrameOperator, DataFrameUnaryOpMixin):
 
 
 class DataFrameArithmeticTreeMixin:
-    def _set_inputs(self, inputs):
-        inputs = self._get_inputs_data(inputs)
-        setattr(self, "_inputs", inputs)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameOperator", inputs: List[EntityData]):
+        inputs = op._get_inputs_data(inputs)
+        setattr(op, "_inputs", inputs)
 
 
 class DataFrameUnaryUfunc(DataFrameUnaryOp, TensorUfuncMixin):

maxframe/dataframe/arithmetic/tests/test_arithmetic.py

@@ -15,6 +15,7 @@
 import datetime
 import operator
 from dataclasses import dataclass
+from math import isinf
 from typing import Callable
 
 import numpy as np
@@ -22,6 +23,7 @@ import pandas as pd
 import pytest
 
 from ....core import OperatorType
+from ....core.operator import estimate_size
 from ....tests.utils import assert_mf_index_dtype
 from ....utils import dataslots
 from ...core import IndexValue
@@ -185,6 +187,10 @@ def test_without_shuffle(func_name, func_opts):
     assert df3.index_value.key != df2.index_value.key
     assert df3.shape[1] == 11  # columns is recorded, so we can get it
 
+    result_ctx = {inp.key: 10 for inp in df3.op.inputs}
+    estimate_size(result_ctx, df3.op)
+    assert result_ctx[df3.key] >= 0 and not isinf(result_ctx[df3.key])
+
 
 @pytest.mark.parametrize("func_name, func_opts", binary_functions.items())
 def test_dataframe_and_series_with_align_map(func_name, func_opts):

maxframe/dataframe/core.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -34,7 +32,7 @@ from ..core import (
     is_build_mode,
     register_output_types,
 )
-from ..core.entity.utils import refresh_tileable_shape
+from ..core.entity.utils import fill_chunk_slices, refresh_tileable_shape
 from ..protocol import DataFrameTableMeta
 from ..serialization.serializables import (
     AnyField,
@@ -303,6 +301,10 @@ class IndexValue(Serializable):
         def names(self) -> list:
             return self._names
 
+        @property
+        def dtypes(self) -> pd.Series:
+            return pd.Series(self._dtypes, index=self._names)
+
         def to_pandas(self):
             data = getattr(self, "_data", None)
             sortorder = getattr(self, "_sortorder", None)
@@ -445,9 +447,7 @@ class DtypesValue(Serializable):
 def refresh_index_value(tileable: ENTITY_TYPE):
     index_to_index_values = dict()
     for chunk in tileable.chunks:
-        if chunk.ndim == 1:
-            index_to_index_values[chunk.index] = chunk.index_value
-        elif chunk.index[1] == 0:
+        if chunk.ndim == 1 or chunk.index[1] == 0:
             index_to_index_values[chunk.index] = chunk.index_value
     index_value = merge_index_value(index_to_index_values, store_data=False)
     # keep key as original index_value's
@@ -637,11 +637,12 @@ class IndexData(HasShapeTileableData, _ToPandasMixin):
     def refresh_params(self):
         # refresh params when chunks updated
         refresh_tileable_shape(self)
-        refresh_index_value(self)
-        if self._dtype is None:
-            self._dtype = self.chunks[0].dtype
-        if self._name is None:
-            self._name = self.chunks[0].name
+        fill_chunk_slices(self)
+        # refresh_index_value(self)
+        # if self._dtype is None:
+        #     self._dtype = self.chunks[0].dtype
+        # if self._name is None:
+        #     self._name = self.chunks[0].name
 
     def refresh_from_table_meta(self, table_meta: DataFrameTableMeta) -> None:
         pass
@@ -696,73 +697,6 @@ class IndexData(HasShapeTileableData, _ToPandasMixin):
 
         return from_index(self, dtype=dtype, extract_multi_index=extract_multi_index)
 
-
-class Index(HasShapeTileable, _ToPandasMixin):
-    __slots__ = "_df_or_series", "_parent_key", "_axis"
-    _allow_data_type_ = (IndexData,)
-    type_name = "Index"
-
-    def __new__(cls, data: Union[pd.Index, IndexData] = None, **_):
-        if data is not None and not isinstance(data, pd.Index):
-            # create corresponding Index class
-            # according to type of index_value
-            clz = globals()[type(data.index_value.value).__name__]
-        else:
-            clz = cls
-        return object.__new__(clz)
-
-    def __len__(self):
-        return len(self._data)
-
-    def __maxframe_tensor__(self, dtype=None, order="K"):
-        return self._data.__maxframe_tensor__(dtype=dtype, order=order)
-
-    def _get_df_or_series(self):
-        obj = getattr(self, "_df_or_series", None)
-        if obj is not None:
-            return obj()
-        return None
-
-    def _set_df_or_series(self, df_or_series, axis):
-        self._df_or_series = weakref.ref(df_or_series)
-        self._parent_key = df_or_series.key
-        self._axis = axis
-
-    @property
-    def T(self):
-        """Return the transpose, which is by definition self."""
-        return self
-
-    @property
-    def name(self):
-        return self._data.name
-
-    @name.setter
-    def name(self, value):
-        df_or_series = self._get_df_or_series()
-        if df_or_series is not None and df_or_series.key == self._parent_key:
-            df_or_series.rename_axis(value, axis=self._axis, inplace=True)
-            self.data = df_or_series.axes[self._axis].data
-        else:
-            self.rename(value, inplace=True)
-
-    @property
-    def names(self):
-        return self._data.names
-
-    @names.setter
-    def names(self, value):
-        df_or_series = self._get_df_or_series()
-        if df_or_series is not None:
-            df_or_series.rename_axis(value, axis=self._axis, inplace=True)
-            self.data = df_or_series.axes[self._axis].data
-        else:
-            self.rename(value, inplace=True)
-
-    @property
-    def values(self):
-        return self.to_tensor()
-
     def to_frame(self, index: bool = True, name=None):
         """
         Create a DataFrame with a column containing the Index.
@@ -838,7 +772,7 @@ class Index(HasShapeTileable, _ToPandasMixin):
             columns = [name or self.name or 0]
         index_ = self if index else None
         return dataframe_from_tensor(
-            self._data._to_maxframe_tensor(self, extract_multi_index=True),
+            self._to_maxframe_tensor(self, extract_multi_index=True),
             index=index_,
             columns=columns,
         )
@@ -867,6 +801,73 @@ class Index(HasShapeTileable, _ToPandasMixin):
         return series_from_index(self, index=index, name=name)
 
 
+class Index(HasShapeTileable, _ToPandasMixin):
+    __slots__ = "_df_or_series", "_parent_key", "_axis"
+    _allow_data_type_ = (IndexData,)
+    type_name = "Index"
+
+    def __new__(cls, data: Union[pd.Index, IndexData] = None, **_):
+        if data is not None and not isinstance(data, pd.Index):
+            # create corresponding Index class
+            # according to type of index_value
+            clz = globals()[type(data.index_value.value).__name__]
+        else:
+            clz = cls
+        return object.__new__(clz)
+
+    def __len__(self):
+        return len(self._data)
+
+    def __maxframe_tensor__(self, dtype=None, order="K"):
+        return self._data.__maxframe_tensor__(dtype=dtype, order=order)
+
+    def _get_df_or_series(self):
+        obj = getattr(self, "_df_or_series", None)
+        if obj is not None:
+            return obj()
+        return None
+
+    def _set_df_or_series(self, df_or_series, axis):
+        self._df_or_series = weakref.ref(df_or_series)
+        self._parent_key = df_or_series.key
+        self._axis = axis
+
+    @property
+    def T(self):
+        """Return the transpose, which is by definition self."""
+        return self
+
+    @property
+    def name(self):
+        return self._data.name
+
+    @name.setter
+    def name(self, value):
+        df_or_series = self._get_df_or_series()
+        if df_or_series is not None and df_or_series.key == self._parent_key:
+            df_or_series.rename_axis(value, axis=self._axis, inplace=True)
+            self.data = df_or_series.axes[self._axis].data
+        else:
+            self.rename(value, inplace=True)
+
+    @property
+    def names(self):
+        return self._data.names
+
+    @names.setter
+    def names(self, value):
+        df_or_series = self._get_df_or_series()
+        if df_or_series is not None:
+            df_or_series.rename_axis(value, axis=self._axis, inplace=True)
+            self.data = df_or_series.axes[self._axis].data
+        else:
+            self.rename(value, inplace=True)
+
+    @property
+    def values(self):
+        return self.to_tensor()
+
+
 class RangeIndex(Index):
     __slots__ = ()
 
@@ -969,11 +970,12 @@ class BaseSeriesData(HasShapeTileableData, _ToPandasMixin):
     def refresh_params(self):
         # refresh params when chunks updated
         refresh_tileable_shape(self)
-        refresh_index_value(self)
+        fill_chunk_slices(self)
+        # refresh_index_value(self)
         if self._dtype is None:
-            self._dtype = self.chunks[0].dtype
-        if self._name is None:
-            self._name = self.chunks[0].name
+            self._dtype = getattr(self.chunks[0], "dtype", None)
+        # if self._name is None:
+        #     self._name = self.chunks[0].name
 
     def refresh_from_table_meta(self, table_meta: DataFrameTableMeta) -> None:
         pass
@@ -1074,6 +1076,12 @@ class SeriesData(_BatchedFetcher, BaseSeriesData):
             into=into
         )
 
+    def to_frame(self, name=None):
+        from . import dataframe_from_tensor
+
+        name = name or self.name or 0
+        return dataframe_from_tensor(self, columns=[name])
+
 
 class Series(HasShapeTileable, _ToPandasMixin):
     __slots__ = ("_cache",)
@@ -1287,10 +1295,7 @@ class Series(HasShapeTileable, _ToPandasMixin):
         1    b
         2    c
         """
-        from . import dataframe_from_tensor
-
-        name = name or self.name or 0
-        return dataframe_from_tensor(self, columns=[name])
+        return self._data.to_frame(name=name)
 
     def between(self, left, right, inclusive="both"):
         """
@@ -1498,8 +1503,8 @@ class BaseDataFrameData(HasShapeTileableData, _ToPandasMixin):
             "shape": self.shape,
             "dtypes": self.dtypes,
             "index_value": self.index_value,
-            "columns_value": self.columns_value,
-            "dtypes_value": self.dtypes_value,
+            "columns_value": getattr(self, "columns_value", None),
+            "dtypes_value": getattr(self, "dtypes_value", None),
         }
 
     def _set_params(self, new_params: Dict[str, Any]):
@@ -1531,8 +1536,9 @@ class BaseDataFrameData(HasShapeTileableData, _ToPandasMixin):
     def refresh_params(self):
         # refresh params when chunks updated
         refresh_tileable_shape(self)
-        refresh_index_value(self)
-        refresh_dtypes(self)
+        fill_chunk_slices(self)
+        # refresh_index_value(self)
+        # refresh_dtypes(self)
 
     def refresh_from_dtypes(self, dtypes: pd.Series) -> None:
         self._dtypes = dtypes
@@ -2227,6 +2233,7 @@ class CategoricalData(HasShapeTileableData, _ToPandasMixin):
     def refresh_params(self):
         # refresh params when chunks updated
         refresh_tileable_shape(self)
+        fill_chunk_slices(self)
         if self._dtype is None:
             self._dtype = self.chunks[0].dtype
         if self._categories_value is None:

maxframe/dataframe/datasource/core.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 
 import asyncio
-from typing import List, Optional
+from typing import List, MutableMapping, Optional, Union
 
 from ...serialization.serializables import Int64Field, StringField
+from ...utils import estimate_pandas_size
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 
 
@@ -79,3 +80,9 @@ class IncrementalIndexDatasource(HeadOptimizedDataSource):
 class PandasDataSourceOperator(DataFrameOperator):
     def get_data(self):
         return getattr(self, "data", None)
+
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "PandasDataSourceOperator"
+    ):
+        ctx[op.outputs[0].key] = estimate_pandas_size(op.get_data())

maxframe/dataframe/datasource/date_range.py

@@ -14,6 +14,7 @@
 
 import warnings
 from datetime import date, datetime, time
+from typing import MutableMapping, Union
 
 import numpy as np
 import pandas as pd
@@ -162,6 +163,13 @@ class DataFrameDateRange(DataFrameOperator, DataFrameOperatorMixin):
             freq=self.freq,
         )
 
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameDateRange"
+    ):  # pragma: no cover
+        # todo implement this to facilitate local computation
+        ctx[op.outputs[0].key] = float("inf")
+
 
 _midnight = time(0, 0)
 

maxframe/dataframe/datasource/from_index.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import List
+
 from ... import opcodes
+from ...core import EntityData
 from ...serialization.serializables import AnyField, KeyField
 from ..initializer import Index
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
@@ -25,11 +28,12 @@ class SeriesFromIndex(DataFrameOperator, DataFrameOperatorMixin):
     index = KeyField("index")
     name = AnyField("name", default=None)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self.input_ = self._inputs[0]
-        if len(self._inputs) > 1:
-            self.index = self._inputs[1]
+    @classmethod
+    def _set_inputs(cls, op: "SeriesFromIndex", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.input_ = op._inputs[0]
+        if len(op._inputs) > 1:
+            op.index = op._inputs[1]
 
     def __call__(self, index, new_index=None, name=None):
         inputs = [index]