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

maxframe/dataframe/misc/apply.py

@@ -13,10 +13,9 @@
 # limitations under the License.
 
 import inspect
-from typing import Any, Union
+from typing import Any, MutableMapping, Union
 
 import numpy as np
-import pandas as pd
 from pandas import DataFrame, Series
 
 from ... import opcodes
@@ -30,14 +29,15 @@ from ...serialization.serializables import (
     StringField,
     TupleField,
 )
-from ...utils import get_func_token, quiet_stdio, tokenize
+from ...udf import BuiltinFunction, MarkedFunction
+from ...utils import copy_if_possible, get_func_token, make_dtype, make_dtypes, tokenize
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import (
+    InferredDataFrameMeta,
     build_df,
     build_series,
     copy_func_scheduling_hints,
-    make_dtype,
-    make_dtypes,
+    infer_dataframe_return_value,
     pack_func_args,
     parse_index,
     validate_axis,
@@ -60,10 +60,11 @@ class ApplyOperandLogicKeyGeneratorMixin(OperatorLogicKeyGeneratorMixin):
             return token_values
 
 
-class ApplyOperator(
+class DataFrameApply(
     DataFrameOperator, DataFrameOperatorMixin, ApplyOperandLogicKeyGeneratorMixin
 ):
     _op_type_ = opcodes.APPLY
+    _legacy_name = "ApplyOperator"
 
     func = FunctionField("func")
     axis = AnyField("axis", default=0)
@@ -83,6 +84,9 @@ class ApplyOperator(
         if hasattr(self, "func"):
             copy_func_scheduling_hints(self.func, self)
 
+    def has_custom_code(self) -> bool:
+        return not isinstance(self.func, BuiltinFunction)
+
     def _update_key(self):
         values = [v for v in self._values_ if v is not self.func] + [
             get_func_token(self.func)
@@ -90,62 +94,48 @@ class ApplyOperator(
         self._obj_set("_key", tokenize(type(self).__name__, *values))
         return self
 
-    def _infer_df_func_returns(self, df, dtypes, dtype=None, name=None, index=None):
+    def _infer_df_func_returns(
+        self, df, dtypes, dtype=None, name=None, index=None
+    ) -> InferredDataFrameMeta:
         if isinstance(self.func, np.ufunc):
             output_type = OutputType.dataframe
-            new_dtypes = None
-            index_value = "inherit"
             new_elementwise = True
         else:
-            if self.output_types is not None and (
-                dtypes is not None or dtype is not None
-            ):
-                ret_dtypes = dtypes if dtypes is not None else (name, dtype)
-                ret_index_value = parse_index(index) if index is not None else None
-                self.elementwise = False
-                return ret_dtypes, ret_index_value
-
-            output_type = new_dtypes = index_value = None
+            output_type = self.output_types[0] if self.output_types else None
             new_elementwise = False
 
-        try:
-            empty_df = build_df(df, size=2)
-            with np.errstate(all="ignore"), quiet_stdio():
-                infer_df = empty_df.apply(
-                    self.func,
-                    axis=self.axis,
-                    raw=self.raw,
-                    result_type=self.result_type,
-                    args=self.args,
-                    **self.kwds,
-                )
-            if index_value is None:
-                if infer_df.index is empty_df.index:
-                    index_value = "inherit"
-                else:
-                    index_value = parse_index(pd.RangeIndex(-1))
-
-            if isinstance(infer_df, pd.DataFrame):
-                output_type = output_type or OutputType.dataframe
-                new_dtypes = new_dtypes or infer_df.dtypes
-            else:
-                output_type = output_type or OutputType.series
-                new_dtypes = (name or infer_df.name, dtype or infer_df.dtype)
-            new_elementwise = False if new_elementwise is None else new_elementwise
-        except:  # noqa: E722  # nosec
-            pass
+        def infer_func(in_df):
+            return in_df.apply(
+                self.func,
+                axis=self.axis,
+                raw=self.raw,
+                result_type=self.result_type,
+                args=self.args,
+                **self.kwds,
+            )
+
+        inferred_meta = infer_dataframe_return_value(
+            df,
+            infer_func,
+            output_type=output_type,
+            dtypes=dtypes,
+            dtype=dtype,
+            name=name,
+            index=index,
+            inherit_index=True,
+            build_kw={"size": 2},
+        )
+        inferred_meta.check_absence("output_type", "dtypes")
 
         self.output_types = (
-            [output_type]
-            if not self.output_types and output_type
+            [inferred_meta.output_type]
+            if not self.output_types and inferred_meta.output_type
             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)
         self.elementwise = (
             new_elementwise if self.elementwise is None else self.elementwise
         )
-        return dtypes, index_value
+        return inferred_meta
 
     def _call_df_or_series(self, df):
         return self.new_df_or_series([df])
@@ -153,20 +143,12 @@ class ApplyOperator(
     def _call_dataframe(self, df, dtypes=None, dtype=None, name=None, index=None):
         # for backward compatibility
         dtype = dtype if dtype is not None else dtypes
-        dtypes, index_value = self._infer_df_func_returns(
+        inferred_meta = self._infer_df_func_returns(
             df, dtypes, dtype=dtype, name=name, index=index
         )
+        index_value = inferred_meta.index_value
         if index_value is None:
             index_value = parse_index(None, (df.key, df.index_value.key))
-        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 == "inherit":
-            index_value = df.index_value
 
         if self.elementwise:
             shape = df.shape
@@ -174,30 +156,21 @@ class ApplyOperator(
             shape = [np.nan, np.nan]
             shape[1 - self.axis] = df.shape[1 - self.axis]
             if self.axis == 1:
-                shape[1] = len(dtypes)
+                shape[1] = len(inferred_meta.dtypes)
             shape = tuple(shape)
         else:
             shape = (df.shape[1 - self.axis],)
 
         if self.output_types[0] == OutputType.dataframe:
-            if self.axis == 0:
-                return self.new_dataframe(
-                    [df],
-                    shape=shape,
-                    dtypes=dtypes,
-                    index_value=index_value,
-                    columns_value=parse_index(dtypes.index, store_data=True),
-                )
-            else:
-                return self.new_dataframe(
-                    [df],
-                    shape=shape,
-                    dtypes=dtypes,
-                    index_value=df.index_value,
-                    columns_value=parse_index(dtypes.index, store_data=True),
-                )
+            kw = dict(
+                shape=shape,
+                dtypes=inferred_meta.dtypes,
+                index_value=index_value if self.axis == 0 else df.index_value,
+                columns_value=parse_index(inferred_meta.dtypes.index, store_data=True),
+            )
+            return self.new_dataframe([df], **kw)
         else:
-            name, dtype = dtypes
+            name, dtype = inferred_meta.name, inferred_meta.dtype
             return self.new_series(
                 [df], shape=shape, name=name, dtype=dtype, index_value=index_value
             )
@@ -205,78 +178,58 @@ class ApplyOperator(
     def _call_series(self, series, dtypes=None, dtype=None, name=None, index=None):
         # for backward compatibility
         dtype = dtype if dtype is not None else dtypes
-        if self.convert_dtype:
-            if self.output_types is not None and (
-                dtypes is not None or dtype is not None
-            ):
-                infer_series = test_series = None
-            else:
-                test_series = build_series(series, size=2, name=series.name)
-                try:
-                    with np.errstate(all="ignore"), quiet_stdio():
-                        infer_series = test_series.apply(
-                            self.func, args=self.args, **self.kwds
-                        )
-                except:  # noqa: E722  # nosec  # pylint: disable=bare-except
-                    infer_series = None
-
-            output_type = self._output_types[0]
-
-            if index is not None:
-                index_value = parse_index(index)
-            elif infer_series is not None:
-                if infer_series.index is test_series.index:
-                    index_value = series.index_value
-                else:  # pragma: no cover
-                    index_value = parse_index(infer_series.index)
-            else:
-                index_value = parse_index(series.index_value)
+        if not self.convert_dtype:
+            dtype = dtype if dtype is not None else np.dtype("object")
+            return self.new_series(
+                [series],
+                dtype=dtype,
+                shape=series.shape,
+                index_value=series.index_value,
+                name=name,
+            )
+        else:
 
+            def infer_func(obj):
+                return obj.apply(self.func, args=self.args, **self.kwds)
+
+            output_type = self.output_types[0] if self.output_types else None
+            inferred_meta = infer_dataframe_return_value(
+                series,
+                infer_func,
+                output_type=output_type,
+                dtypes=dtypes,
+                dtype=dtype,
+                name=name,
+                index=index,
+                inherit_index=True,
+                build_kw={"size": 2},
+            )
+
+            output_type = inferred_meta.output_type or output_type
             if output_type == OutputType.dataframe:
+                dtypes = inferred_meta.dtypes
                 if dtypes is None:
-                    if infer_series is not None and infer_series.ndim == 2:
-                        dtypes = infer_series.dtypes
-                    else:
-                        raise TypeError(
-                            "Cannot determine dtypes, "
-                            "please specify `dtypes` as argument"
-                        )
-                columns_value = parse_index(dtypes.index, store_data=True)
-
+                    raise TypeError(
+                        "Cannot determine dtypes, please specify `dtypes` as argument"
+                    )
                 return self.new_dataframe(
                     [series],
                     shape=(series.shape[0], len(dtypes)),
-                    index_value=index_value,
-                    columns_value=columns_value,
-                    dtypes=dtypes,
+                    index_value=inferred_meta.index_value,
+                    columns_value=parse_index(
+                        inferred_meta.dtypes.index, store_data=True
+                    ),
+                    dtypes=inferred_meta.dtypes,
                 )
             else:
-                if (
-                    dtype is None
-                    and infer_series is not None
-                    and infer_series.ndim == 1
-                ):
-                    dtype = infer_series.dtype
-                else:
-                    dtype = dtype if dtype is not None else np.dtype(object)
-                if infer_series is not None and infer_series.ndim == 1:
-                    name = name or infer_series.name
+                dtype = inferred_meta.dtype or np.dtype("O")
                 return self.new_series(
                     [series],
                     dtype=dtype,
                     shape=series.shape,
-                    index_value=index_value,
-                    name=name,
+                    index_value=inferred_meta.index_value,
+                    name=inferred_meta.name,
                 )
-        else:
-            dtype = dtype if dtype is not None else np.dtype("object")
-            return self.new_series(
-                [series],
-                dtype=dtype,
-                shape=series.shape,
-                index_value=series.index_value,
-                name=name,
-            )
 
     def __call__(self, df_or_series, dtypes=None, dtype=None, name=None, index=None):
         axis = getattr(self, "axis", None) or 0
@@ -303,7 +256,21 @@ class ApplyOperator(
 
     def get_packed_funcs(self, df=None) -> Any:
         stub_df = self._build_stub_pandas_obj(df or self.inputs[0])
-        return pack_func_args(stub_df, self.func, *self.args, **self.kwds)
+        args = copy_if_possible(self.args)
+        kwargs = copy_if_possible(self.kwds)
+        return pack_func_args(stub_df, self.func, *args, **kwargs)
+
+    @classmethod
+    def estimate_size(
+        cls, ctx: MutableMapping[str, Union[int, float]], op: "DataFrameApply"
+    ) -> None:
+        if isinstance(op.func, MarkedFunction):
+            ctx[op.outputs[0].key] = float("inf")
+        super().estimate_size(ctx, op)
+
+
+# keep for import compatibility
+ApplyOperator = DataFrameApply
 
 
 def df_apply(
@@ -546,7 +513,7 @@ def df_apply(
             kwds["axis"] = axis
         return func(*args, **kwds)
 
-    op = ApplyOperator(
+    op = DataFrameApply(
         func=func,
         axis=axis,
         raw=raw,
@@ -753,7 +720,7 @@ def series_apply(
     )
     output_type = output_types[0] if output_types else OutputType.series
 
-    op = ApplyOperator(
+    op = DataFrameApply(
         func=func,
         convert_dtype=convert_dtype,
         args=args,

maxframe/dataframe/misc/astype.py

@@ -17,7 +17,7 @@ from pandas.api.types import CategoricalDtype
 
 from ... import opcodes
 from ...serialization.serializables import AnyField, ListField, StringField
-from ...utils import pd_release_version
+from ...utils import make_dtypes, pd_release_version
 from ..core import DATAFRAME_TYPE, SERIES_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import build_empty_df, build_empty_series, parse_index
@@ -184,6 +184,7 @@ def astype(df, dtype, copy=True, errors="raise"):
     1     2
     dtype: int64
     """
+    dtype = make_dtypes(dtype, make_series=False)
     if isinstance(dtype, dict):
         keys = list(dtype.keys())
         if isinstance(df, SERIES_TYPE):
@@ -233,4 +234,4 @@ def index_astype(ix, dtype, copy=True):
     Index
         Index with values cast to specified dtype.
     """
-    return astype(ix, dtype, copy=copy)
+    return astype(ix, make_dtypes(dtype), copy=copy)

maxframe/dataframe/misc/case_when.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
 from pandas.core.dtypes.cast import find_common_type
 
 from ... import opcodes
-from ...core import TILEABLE_TYPE
+from ...core import TILEABLE_TYPE, EntityData
 from ...serialization.serializables import FieldTypes, ListField
 from ..core import SERIES_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
@@ -32,21 +34,23 @@ class DataFrameCaseWhen(DataFrameOperator, DataFrameOperatorMixin):
     def __init__(self, output_types=None, **kw):
         super().__init__(_output_types=output_types, **kw)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameCaseWhen", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
         it = iter(inputs)
         next(it)
-        self.conditions = [
-            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in self.conditions
+        op.conditions = [
+            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in op.conditions
         ]
-        self.replacements = [
-            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in self.replacements
+        op.replacements = [
+            next(it) if isinstance(t, TILEABLE_TYPE) else t for t in op.replacements
         ]
 
     def __call__(self, series):
         replacement_dtypes = [
             it.dtype if isinstance(it, SERIES_TYPE) else np.array(it).dtype
             for it in self.replacements
+            if it is not None
         ]
         dtype = find_common_type([series.dtype] + replacement_dtypes)
 

maxframe/dataframe/misc/cut.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, ExecutableTuple, OutputType
+from ...core import ENTITY_TYPE, EntityData, ExecutableTuple, OutputType
 from ...serialization.serializables import (
     AnyField,
     BoolField,
@@ -55,14 +56,15 @@ class DataFrameCut(DataFrameOperator, DataFrameOperatorMixin):
     def output_limit(self):
         return 1 if not self.retbins else 2
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs)
-        self._input = next(inputs_iter)
-        if isinstance(self.bins, ENTITY_TYPE):
-            self.bins = next(inputs_iter)
-        if isinstance(self.labels, ENTITY_TYPE):
-            self.labels = next(inputs_iter)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameCut", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs)
+        op._input = next(inputs_iter)
+        if isinstance(op.bins, ENTITY_TYPE):
+            op.bins = next(inputs_iter)
+        if isinstance(op.labels, ENTITY_TYPE):
+            op.labels = next(inputs_iter)
 
     def __call__(self, x):
         if isinstance(x, pd.Series):
@@ -77,7 +79,6 @@ class DataFrameCut(DataFrameOperator, DataFrameOperatorMixin):
         inputs = [x]
         if self.labels is not None and not isinstance(self.labels, (bool, ENTITY_TYPE)):
             self.labels = np.asarray(self.labels)
-
         # infer dtype
         x_empty = (
             pd.Series([1], dtype=x.dtype)

maxframe/dataframe/misc/describe.py

@@ -12,10 +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 EntityData
 from ...serialization.serializables import AnyField, FieldTypes, KeyField, ListField
 from ..core import SERIES_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
@@ -33,9 +36,10 @@ class DataFrameDescribe(DataFrameOperator, DataFrameOperatorMixin):
     def __init__(self, output_types=None, **kw):
         super().__init__(_output_types=output_types, **kw)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self.input = self._inputs[0]
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameDescribe", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.input = op._inputs[0]
 
     def __call__(self, df_or_series):
         if isinstance(df_or_series, SERIES_TYPE):

maxframe/dataframe/misc/drop.py

@@ -13,15 +13,16 @@
 # limitations under the License.
 
 import warnings
+from typing import List
 
 import numpy as np
 
-from maxframe import opcodes
-from maxframe.core import Entity, OutputType
-from maxframe.dataframe.core import DATAFRAME_TYPE, SERIES_TYPE, IndexValue
-from maxframe.dataframe.operators import DataFrameOperator, DataFrameOperatorMixin
-from maxframe.dataframe.utils import parse_index, validate_axis
-from maxframe.serialization.serializables import AnyField, StringField
+from ... import opcodes
+from ...core import Entity, EntityData, OutputType
+from ...serialization.serializables import AnyField, StringField
+from ..core import DATAFRAME_TYPE, SERIES_TYPE, IndexValue
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
 
 
 class DataFrameDrop(DataFrameOperatorMixin, DataFrameOperator):
@@ -42,11 +43,12 @@ class DataFrameDrop(DataFrameOperatorMixin, DataFrameOperator):
         else:
             return dtypes
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs[1:])
-        if len(self._inputs) > 1:
-            self.index = next(inputs_iter)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameDrop", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs[1:])
+        if len(op._inputs) > 1:
+            op.index = next(inputs_iter)
 
     def __call__(self, df_or_series):
         params = df_or_series.params.copy()

maxframe/dataframe/misc/eval.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");