maxframe 2.2.0__tar.gz → 2.3.0rc1__tar.gz

{maxframe-2.2.0/maxframe.egg-info → maxframe-2.3.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maxframe
-Version: 2.2.0
+Version: 2.3.0rc1
 Summary: MaxFrame operator-based data analyze framework
 Requires-Dist: numpy<2.0.0,>=1.19.0
 Requires-Dist: pandas>=1.0.0
@@ -107,4 +107,3 @@ License
 
 Licensed under the `Apache License
 2.0 <https://www.apache.org/licenses/LICENSE-2.0.html>`__.
-

{maxframe-2.2.0 → maxframe-2.3.0rc1}/README.rst

@@ -71,4 +71,3 @@ License
 
 Licensed under the `Apache License
 2.0 <https://www.apache.org/licenses/LICENSE-2.0.html>`__.
-

{maxframe-2.2.0 → maxframe-2.3.0rc1}/_cythonize_all.py

@@ -70,7 +70,7 @@ def cythonize_all_pyx(repo_root, source_to_ext_include=None):
     source_to_ext_include = source_to_ext_include or dict()
     for root, _, files in os.walk(repo_root):
         # skip build dir
-        if "/build/" in root:
+        if "/build/" in root.replace("\\", "/"):
             continue
 
         for fn in files:

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/core.py

@@ -23,7 +23,7 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Type, Union
 from odps.types import OdpsSchema
 from odps.utils import camel_to_underline
 
-from ..core import OperatorType, Tileable, TileableGraph
+from ..core import OperatorType, Tileable, TileableGraph, enter_mode
 from ..core.operator import Fetch, Operator
 from ..extension import iter_extensions
 from ..io.odpsio import build_dataframe_table_meta
@@ -465,6 +465,7 @@ class DAGCodeGenerator(metaclass=abc.ABCMeta):
     def _generate_delete_code(self, var_name: str) -> List[str]:
         return []
 
+    @enter_mode(build=True)
     def generate_code(self, dag: TileableGraph) -> List[str]:
         """
         Generate the code of the input dag.
@@ -494,7 +495,7 @@ class DAGCodeGenerator(metaclass=abc.ABCMeta):
             code_lines.extend(adapter.generate_pre_op_code(op, self._context))
             if self._generate_comments_enabled:
                 code_lines.extend(adapter.generate_comment(op, self._context))
-            code_lines.extend(adapter.generate_code(op, self._context))
+            code_lines.extend(adapter.generate_code(op, self._context) or [])
             code_lines.extend(adapter.generate_post_op_code(op, self._context))
             code_lines.append("")  # Append an empty line to separate operators
 

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/spe/dataframe/merge.py

@@ -15,6 +15,7 @@
 from typing import List
 
 from ....dataframe.merge import (
+    DataFrameCombine,
     DataFrameCompare,
     DataFrameConcat,
     DataFrameMerge,
@@ -23,6 +24,9 @@ from ....dataframe.merge import (
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
 from ..utils import build_method_call_adapter
 
+DataFrameCombineAdapter = build_method_call_adapter(
+    DataFrameCombine, "combine", 1, "func", kw_keys=["fill_value"]
+)
 DataFrameCompareAdapter = build_method_call_adapter(
     DataFrameCompare,
     "compare",

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/spe/dataframe/misc.py

@@ -32,6 +32,7 @@ from ....dataframe.misc.get_dummies import DataFrameGetDummies
 from ....dataframe.misc.isin import DataFrameIsin
 from ....dataframe.misc.map import DataFrameMap
 from ....dataframe.misc.memory_usage import DataFrameMemoryUsage
+from ....dataframe.misc.repeat import DataFrameRepeat
 from ....dataframe.misc.shift import DataFrameShift
 from ....dataframe.misc.to_numeric import DataFrameToNumeric
 from ....dataframe.misc.transform import DataFrameTransform
@@ -127,6 +128,7 @@ class DataFrameIsinAdapter(SPEOperatorAdapter):
 DataFrameMapAdapter = build_method_call_adapter(
     DataFrameMap, "map", "arg", na_action=None
 )
+DataFrameRepeatAdapter = build_method_call_adapter(DataFrameRepeat, "repeat", "repeats")
 DataFrameShiftAdapter = build_method_call_adapter(
     DataFrameShift, "shift", kw_keys=["periods", "freq", "axis", "fill_value"]
 )

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/spe/dataframe/reduction.py

@@ -28,6 +28,7 @@ from ....dataframe.reduction import (
     DataFrameMean,
     DataFrameMedian,
     DataFrameMin,
+    DataFrameMode,
     DataFrameNunique,
     DataFrameProd,
     DataFrameSem,
@@ -163,3 +164,20 @@ class DataFrameUniqueAdapter(SPEOperatorAdapter):
         input_var_name = context.get_input_tileable_variable(op.inputs[0])
         res_var_name = context.get_output_tileable_variable(op.outputs[0])
         return [f"{res_var_name} = pd.unique({input_var_name})"]
+
+
+@register_op_adapter(DataFrameMode)
+class DataFrameModeAdapter(SPEOperatorAdapter):
+    def generate_code(self, op: DataFrameMode, context: SPECodeContext) -> List[str]:
+        input_var_name = context.get_input_tileable_variable(op.inputs[0])
+        args = []
+        if op.inputs[0].ndim == 2:
+            if op.axis is not None:
+                args.append(f"axis={op.axis!r}")
+            if op.numeric_only is not None:
+                args.append(f"numeric_only={op.numeric_only!r}")
+        if op.dropna is not None:
+            args.append(f"dropna={op.dropna!r}")
+        args_str = ", ".join(args)
+        res_var_name = context.get_output_tileable_variable(op.outputs[0])
+        return [f"{res_var_name} = {input_var_name}.mode({args_str})"]

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/spe/dataframe/sort.py

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

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/spe/dataframe/tseries.py

@@ -14,9 +14,18 @@
 
 from typing import List
 
+from ....dataframe.tseries.between_time import DataFrameBetweenTime
 from ....dataframe.tseries.to_datetime import DataFrameToDatetime
 from ....utils import no_default
 from ..core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
+from ..utils import build_method_call_adapter
+
+DataFrameBetweenTimeAdapter = build_method_call_adapter(
+    DataFrameBetweenTime,
+    "between_time",
+    kw_keys=["start_time", "end_time", "inclusive", "axis"],
+    skip_none=True,
+)
 
 
 @register_op_adapter(DataFrameToDatetime)

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/spe/learn/contrib/lightgbm.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import inspect
-from typing import List
+from typing import List, Optional
 
 from .....learn.contrib.lightgbm._predict import LGBMPredict
 from .....learn.contrib.lightgbm._train import LGBMTrain
@@ -23,11 +23,12 @@ from ...core import SPECodeContext, SPEOperatorAdapter, register_op_adapter
 
 
 class _LightGBMAdapter(SPEOperatorAdapter):
-    def generate_code(self, op: OperatorType, context: SPECodeContext) -> List[str]:
+    def generate_code(
+        self, op: OperatorType, context: SPECodeContext
+    ) -> Optional[List[str]]:
         context.register_import("lightgbm")
         context.register_import("pandas", "pd")
         context.register_import("numpy", "np")
-        return []
 
 
 @register_op_adapter(ToLGBMDataset)

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/codegen/spe/tensor/datasource.py

@@ -142,6 +142,7 @@ class TensorOnesZerosLikeAdapter(SPEOperatorAdapter):
         ]
 
 
+@register_op_adapter(Scalar)
 class TensorScalarAdapter(SPEOperatorAdapter):
     def accepts(self, op: Scalar) -> EngineAcceptance:
         return EngineAcceptance.SUCCESSOR

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/config/config.py

@@ -435,6 +435,9 @@ default_options.register_option(
 default_options.register_option(
     "session.quota_name", None, validator=is_null | is_string, remote=True
 )
+default_options.register_option(
+    "session.gu_quota_name", None, validator=is_null | is_string, remote=True
+)
 default_options.register_option(
     "session.region_id", None, validator=is_null | is_string, remote=True
 )

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/core/base.py

@@ -126,12 +126,13 @@ class Base(Serializable):
 
     def to_kv(
         self,
-        exclude_fields: Tuple[str],
+        exclude_fields: Tuple[str] = None,
         accept_value_types: Optional[Tuple[Type]] = None,
     ):
         fields = self._FIELDS
         kv = {}
         no_value = object()
+        exclude_fields = exclude_fields or ()
         for name, field in fields.items():
             if name not in exclude_fields:
                 value = getattr(self, name, no_value)

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/core/entity/tileables.py

@@ -318,6 +318,8 @@ class HasShapeTileableData(TileableData):
         try:
             return int(self.shape[0])
         except (IndexError, ValueError):  # pragma: no cover
+            if len(self.shape) == 0:
+                raise TypeError("len() of unsized object") from None
             return 0
 
     @property

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/core/graph/entity.py

@@ -117,10 +117,11 @@ class SerializableGraph(Serializable):
     _successors = DictField("successors")
     _results = ListField("results")
     _graph_cls = StringField("graph_cls")
+    _extra_params = DictField("extra_params", default=None)
 
     @classmethod
     def from_graph(cls, graph: EntityGraph) -> "SerializableGraph":
-        return SerializableGraph(
+        kw = dict(
             _is_chunk=False,
             _fetch_nodes=[chunk for chunk in graph if chunk.is_fetch()],
             _nodes=graph._nodes,
@@ -129,6 +130,9 @@ class SerializableGraph(Serializable):
             _results=graph.results,
             _graph_cls=extract_class_name(type(graph)),
         )
+        if hasattr(graph, "extra_params"):
+            kw["_extra_params"] = graph.extra_params
+        return SerializableGraph(**kw)
 
     def to_graph(self) -> EntityGraph:
         graph_cls = (
@@ -140,6 +144,8 @@ class SerializableGraph(Serializable):
         graph._nodes.update(self._nodes)
         graph._predecessors.update(self._predecessors)
         graph._successors.update(self._successors)
+        if self._extra_params:
+            graph.extra_params = self._extra_params
         return graph
 
 

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/core/mode.py

@@ -42,6 +42,10 @@ def is_build_mode():
     return bool(getattr(_internal_mode, "build", False))
 
 
+def is_mock_mode():
+    return bool(getattr(_internal_mode, "mock", False))
+
+
 class _EnterModeFuncWrapper:
     def __init__(self, mode_name_to_value):
         self.mode_name_to_value = mode_name_to_value
@@ -86,10 +90,11 @@ class _EnterModeFuncWrapper:
         return _inner
 
 
-def enter_mode(kernel=None, build=None):
+def enter_mode(kernel=None, build=None, mock=None):
     mode_name_to_value = {
         "kernel": kernel,
         "build": build,
+        "mock": mock,
     }
     mode_name_to_value = {k: v for k, v in mode_name_to_value.items() if v is not None}
 

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/dataframe/__init__.py

@@ -32,6 +32,7 @@ from . import (
     window,
 )
 from .datasource.date_range import date_range
+from .datasource.direct import read_clipboard
 from .datasource.from_index import series_from_index
 from .datasource.from_records import from_records
 from .datasource.from_tensor import dataframe_from_tensor, series_from_tensor
@@ -40,7 +41,6 @@ from .datasource.read_odps_query import read_odps_query
 from .datasource.read_odps_table import read_odps_table
 from .datasource.read_parquet import read_parquet
 from .datastore.to_odps import to_odps_table
-from .groupby import NamedAgg
 from .initializer import DataFrame, Index, Series, read_pandas
 from .merge import concat, merge
 from .misc.cut import cut
@@ -49,7 +49,7 @@ from .misc.get_dummies import get_dummies
 from .misc.qcut import qcut
 from .misc.to_numeric import to_numeric
 from .missing import isna, isnull, notna, notnull
-from .reduction import CustomReduction, unique
+from .reduction import CustomReduction, NamedAgg, unique
 from .reshape.melt import melt
 from .reshape.pivot import pivot
 from .reshape.pivot_table import pivot_table

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/dataframe/arithmetic/__init__.py

@@ -53,6 +53,8 @@ from .less_equal import DataFrameLessEqual, le
 from .log import DataFrameLog
 from .log2 import DataFrameLog2
 from .log10 import DataFrameLog10
+from .maximum import DataFrameMaximum
+from .minimum import DataFrameMinimum
 from .mod import DataFrameMod, mod, rmod
 from .multiply import DataFrameMul, mul, rmul
 from .negative import DataFrameNegative, negative
@@ -250,6 +252,8 @@ def _install():
         DataFramePower,
         DataFrameSubtract,
         DataFrameTrueDiv,
+        DataFrameMaximum,
+        DataFrameMinimum,
     ]
     for ufunc_op in ufunc_ops:
         register_tensor_ufunc(ufunc_op)

maxframe-2.3.0rc1/maxframe/dataframe/arithmetic/maximum.py

@@ -0,0 +1,33 @@
+# 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 ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+
+
+class DataFrameMaximum(DataFrameBinopUfunc):
+    _op_type_ = opcodes.MAXIMUM
+
+    @classproperty
+    def _operator(self):
+        return np.maximum
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorMaximum
+
+        return TensorMaximum

maxframe-2.3.0rc1/maxframe/dataframe/arithmetic/minimum.py

@@ -0,0 +1,33 @@
+# 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 ... import opcodes
+from ...utils import classproperty
+from .core import DataFrameBinopUfunc
+
+
+class DataFrameMinimum(DataFrameBinopUfunc):
+    _op_type_ = opcodes.MINIMUM
+
+    @classproperty
+    def _operator(self):
+        return np.minimum
+
+    @classproperty
+    def tensor_op_type(self):
+        from ...tensor.arithmetic import TensorMinimum
+
+        return TensorMinimum

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/dataframe/core.py

@@ -715,55 +715,6 @@ class IndexData(HasShapeTileableData, _ToPandasMixin):
         return from_index(self, dtype=dtype, extract_multi_index=extract_multi_index)
 
     def to_frame(self, index: bool = True, name=None):
-        """
-        Create a DataFrame with a column containing the Index.
-
-        Parameters
-        ----------
-        index : bool, default True
-            Set the index of the returned DataFrame as the original Index.
-
-        name : object, default None
-            The passed name should substitute for the index name (if it has
-            one).
-
-        Returns
-        -------
-        DataFrame
-            DataFrame containing the original Index data.
-
-        See Also
-        --------
-        Index.to_series : Convert an Index to a Series.
-        Series.to_frame : Convert Series to DataFrame.
-
-        Examples
-        --------
-        >>> import maxframe.dataframe as md
-        >>> idx = md.Index(['Ant', 'Bear', 'Cow'], name='animal')
-        >>> idx.to_frame().execute()
-               animal
-        animal
-        Ant       Ant
-        Bear     Bear
-        Cow       Cow
-
-        By default, the original Index is reused. To enforce a new Index:
-
-        >>> idx.to_frame(index=False).execute()
-          animal
-        0    Ant
-        1   Bear
-        2    Cow
-
-        To override the name of the resulting column, specify `name`:
-
-        >>> idx.to_frame(index=False, name='zoo').execute()
-            zoo
-        0   Ant
-        1  Bear
-        2   Cow
-        """
         from . import dataframe_from_tensor
 
         if isinstance(self.index_value.value, IndexValue.MultiIndex):
@@ -789,34 +740,20 @@ class IndexData(HasShapeTileableData, _ToPandasMixin):
             columns = [name or self.name or 0]
         index_ = self if index else None
         return dataframe_from_tensor(
-            self._to_maxframe_tensor(self, extract_multi_index=True),
+            self._to_maxframe_tensor(extract_multi_index=True),
             index=index_,
             columns=columns,
         )
 
     def to_series(self, index=None, name=None):
-        """
-        Create a Series with both index and values equal to the index keys.
-
-        Useful with map for returning an indexer based on an index.
-
-        Parameters
-        ----------
-        index : Index, optional
-            Index of resulting Series. If None, defaults to original index.
-        name : str, optional
-            Dame of resulting Series. If None, defaults to name of original
-            index.
-
-        Returns
-        -------
-        Series
-            The dtype will be based on the type of the Index values.
-        """
         from . import series_from_index
 
         return series_from_index(self, index=index, name=name)
 
+    @property
+    def hasnans(self):
+        return self.isna().any()
+
 
 class Index(HasShapeTileable, _ToPandasMixin):
     __slots__ = "_df_or_series", "_parent_key", "_axis"
@@ -887,6 +824,99 @@ class Index(HasShapeTileable, _ToPandasMixin):
     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.
+
+        Parameters
+        ----------
+        index : bool, default True
+            Set the index of the returned DataFrame as the original Index.
+
+        name : object, default None
+            The passed name should substitute for the index name (if it has
+            one).
+
+        Returns
+        -------
+        DataFrame
+            DataFrame containing the original Index data.
+
+        See Also
+        --------
+        Index.to_series : Convert an Index to a Series.
+        Series.to_frame : Convert Series to DataFrame.
+
+        Examples
+        --------
+        >>> import maxframe.dataframe as md
+        >>> idx = md.Index(['Ant', 'Bear', 'Cow'], name='animal')
+        >>> idx.to_frame().execute()
+               animal
+        animal
+        Ant       Ant
+        Bear     Bear
+        Cow       Cow
+
+        By default, the original Index is reused. To enforce a new Index:
+
+        >>> idx.to_frame(index=False).execute()
+          animal
+        0    Ant
+        1   Bear
+        2    Cow
+
+        To override the name of the resulting column, specify `name`:
+
+        >>> idx.to_frame(index=False, name='zoo').execute()
+            zoo
+        0   Ant
+        1  Bear
+        2   Cow
+        """
+        return self._data.to_frame(index=index, name=name)
+
+    def to_series(self, index=None, name=None):
+        """
+        Create a Series with both index and values equal to the index keys.
+
+        Useful with map for returning an indexer based on an index.
+
+        Parameters
+        ----------
+        index : Index, optional
+            Index of resulting Series. If None, defaults to original index.
+        name : str, optional
+            Dame of resulting Series. If None, defaults to name of original
+            index.
+
+        Returns
+        -------
+        Series
+            The dtype will be based on the type of the Index values.
+        """
+        return self._data.to_series(index=index, name=name)
+
+    @property
+    def hasnans(self):
+        """
+        Return True if there are any NaNs.
+
+        Returns
+        -------
+        bool
+
+        Examples
+        --------
+        >>> import maxframe.dataframe as md
+        >>> idx = md.Index([1, 2, 3, None])
+        >>> idx.execute()
+        Index([1.0, 2.0, 3.0, nan], dtype='float64')
+        >>> idx.hasnans.execute()
+        True
+        """
+        return self._data.hasnans
+
 
 class RangeIndex(Index):
     __slots__ = ()
@@ -1085,12 +1115,6 @@ class SeriesData(_BatchedFetcher, BaseSeriesData):
 
     items = iteritems
 
-    def to_dict(self, into=dict, batch_size=10000, session=None):
-        fetch_kwargs = dict(batch_size=batch_size)
-        return self.to_pandas(session=session, fetch_kwargs=fetch_kwargs).to_dict(
-            into=into
-        )
-
     def to_frame(self, name=None):
         from . import dataframe_from_tensor
 
@@ -1285,38 +1309,6 @@ class Series(HasShapeTileable, _ToPandasMixin):
 
     items = iteritems
 
-    def to_dict(self, into=dict, batch_size=10000, session=None):
-        """
-        Convert Series to {label -> value} dict or dict-like object.
-
-        Parameters
-        ----------
-        into : class, default dict
-            The collections.abc.Mapping subclass to use as the return
-            object. Can be the actual class or an empty
-            instance of the mapping type you want.  If you want a
-            collections.defaultdict, you must pass it initialized.
-
-        Returns
-        -------
-        collections.abc.Mapping
-            Key-value representation of Series.
-
-        Examples
-        --------
-        >>> import maxframe.dataframe as md
-        >>> s = md.Series([1, 2, 3, 4])
-        >>> s.to_dict()
-        {0: 1, 1: 2, 2: 3, 3: 4}
-        >>> from collections import OrderedDict, defaultdict
-        >>> s.to_dict(OrderedDict)
-        OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)])
-        >>> dd = defaultdict(list)
-        >>> s.to_dict(dd)
-        defaultdict(<class 'list'>, {0: 1, 1: 2, 2: 3, 3: 4})
-        """
-        return self._data.to_dict(into=into, batch_size=batch_size, session=session)
-
     def to_frame(self, name=None):
         """
         Convert Series to DataFrame.

{maxframe-2.2.0 → maxframe-2.3.0rc1}/maxframe/dataframe/datasource/core.py

@@ -18,6 +18,7 @@ from typing import List, MutableMapping, Optional, Union
 from ...serialization.serializables import Int64Field, StringField
 from ...utils import estimate_pandas_size
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import validate_dtype_backend
 
 
 class HeadOptimizedDataSource(DataFrameOperator, DataFrameOperatorMixin):
@@ -86,3 +87,8 @@ class PandasDataSourceOperator(DataFrameOperator):
         cls, ctx: MutableMapping[str, Union[int, float]], op: "PandasDataSourceOperator"
     ):
         ctx[op.outputs[0].key] = estimate_pandas_size(op.get_data())
+
+
+class DtypeBackendCompatibleMixin:
+    def __on_deserialize__(self):
+        self.dtype_backend = validate_dtype_backend(self.dtype_backend)