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

maxframe/dataframe/indexing/loc.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from numbers import Integral
-from typing import Dict
+from typing import Dict, List
 
 import numpy as np
 import pandas as pd
@@ -21,7 +21,7 @@ from pandas.core.dtypes.cast import find_common_type
 from pandas.core.indexing import IndexingError
 
 from ... import opcodes
-from ...core import ENTITY_TYPE, OutputType
+from ...core import ENTITY_TYPE, EntityData, OutputType
 from ...serialization.serializables import AnyField, KeyField, ListField
 from ...tensor.datasource import asarray
 from ...tensor.utils import calc_sliced_size, filter_inputs
@@ -182,17 +182,18 @@ class DataFrameLocGetItem(DataFrameOperator, DataFrameOperatorMixin):
     def can_index_miss(self):
         return False
 
-    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: "DataFrameLocGetItem", 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 = list(indexes)
+        op.indexes = list(indexes)
 
     @classmethod
     def _calc_slice_param(

maxframe/dataframe/indexing/reindex.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import List
+
 import numpy as np
 
 try:
@@ -20,7 +22,7 @@ except ImportError:  # pragma: no cover
     sps = None
 
 from ... import opcodes
-from ...core import ENTITY_TYPE
+from ...core import ENTITY_TYPE, EntityData
 from ...serialization.serializables import (
     AnyField,
     BoolField,
@@ -53,6 +55,7 @@ class DataFrameReindex(DataFrameOperator, DataFrameOperatorMixin):
     level = AnyField("level", default=None)
     fill_value = AnyField("fill_value", default=None)
     limit = Int64Field("limit", default=None)
+    tolerance = Int64Field("tolerance", default=None)
     enable_sparse = BoolField("enable_sparse", default=None)
 
     @property
@@ -86,14 +89,15 @@ class DataFrameReindex(DataFrameOperator, DataFrameOperatorMixin):
     def can_index_miss(self):
         return True
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs)
-        self._input = next(inputs_iter)
-        if self.index is not None and isinstance(self.index, ENTITY_TYPE):
-            self.index = next(inputs_iter)
-        if self.fill_value is not None and isinstance(self.fill_value, ENTITY_TYPE):
-            self.fill_value = next(inputs_iter)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameReindex", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs)
+        op._input = next(inputs_iter)
+        if op.index is not None and isinstance(op.index, ENTITY_TYPE):
+            op.index = next(inputs_iter)
+        if op.fill_value is not None and isinstance(op.fill_value, ENTITY_TYPE):
+            op.fill_value = next(inputs_iter)
 
     def __call__(self, df_or_series):
         inputs = [df_or_series]
@@ -137,7 +141,21 @@ class DataFrameReindex(DataFrameOperator, DataFrameOperatorMixin):
             )
 
 
-def reindex(df_or_series, *args, **kwargs):
+def reindex(
+    df_or_series,
+    labels=None,
+    *,
+    index=None,
+    columns=None,
+    axis=None,
+    method=None,
+    copy=None,
+    level=None,
+    fill_value=None,
+    limit=None,
+    tolerance=None,
+    enable_sparse=False
+):
     """
     Conform Series/DataFrame to new index with optional filling logic.
 
@@ -342,26 +360,14 @@ def reindex(df_or_series, *args, **kwargs):
 
     See the :ref:`user guide <basics.reindexing>` for more.
     """
-    axes = validate_axis_style_args(df_or_series, args, kwargs, "labels", "reindex")
-    # Pop these, since the values are in `kwargs` under different names
-    kwargs.pop("index", None)
-    if df_or_series.ndim > 1:
-        kwargs.pop("columns", None)
-        kwargs.pop("axis", None)
-        kwargs.pop("labels", None)
-    method = kwargs.pop("method", None)
-    level = kwargs.pop("level", None)
-    copy = kwargs.pop("copy", True)
-    limit = kwargs.pop("limit", None)
-    tolerance = kwargs.pop("tolerance", None)
-    fill_value = kwargs.pop("fill_value", None)
-    enable_sparse = kwargs.pop("enable_sparse", None)
-
-    if kwargs:
-        raise TypeError(
-            "reindex() got an unexpected keyword "
-            f'argument "{list(kwargs.keys())[0]}"'
-        )
+    axes_kwargs = dict(index=index, columns=columns, axis=axis)
+    axes = validate_axis_style_args(
+        df_or_series,
+        (labels,),
+        {k: v for k, v in axes_kwargs.items() if v is not None},
+        "labels",
+        "reindex",
+    )
 
     if tolerance is not None:  # pragma: no cover
         raise NotImplementedError("`tolerance` is not supported yet")

maxframe/dataframe/indexing/rename_axis.py

@@ -14,7 +14,8 @@
 
 from ... import opcodes
 from ...core import OutputType
-from ...serialization.serializables import AnyField, BoolField
+from ...serialization.serializables import AnyField, BoolField, Int32Field
+from ...utils import no_default
 from ..core import DATAFRAME_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import build_df, build_series, parse_index, validate_axis
@@ -27,6 +28,7 @@ class DataFrameRenameAxis(DataFrameOperator, DataFrameOperatorMixin):
     columns = AnyField("columns", default=None)
     copy_value = BoolField("copy_value", default=None)
     level = AnyField("level", default=None)
+    axis = Int32Field("axis", default=0)
 
     @staticmethod
     def _update_params(params, obj, mapper, axis, level):
@@ -54,7 +56,7 @@ class DataFrameRenameAxis(DataFrameOperator, DataFrameOperatorMixin):
         else:
             self._output_types = [OutputType.series]
 
-        if self.index is not None:
+        if self.axis == 0:
             self._update_params(
                 params, df_or_series, self.index, axis=0, level=self.level
             )
@@ -68,21 +70,27 @@ class DataFrameRenameAxis(DataFrameOperator, DataFrameOperatorMixin):
 
 def rename_axis_with_level(
     df_or_series,
-    mapper=None,
-    index=None,
-    columns=None,
+    mapper=no_default,
+    index=no_default,
+    columns=no_default,
     axis=0,
     copy=True,
     level=None,
     inplace=False,
 ):
     axis = validate_axis(axis, df_or_series)
-    if mapper is not None:
+    if mapper is not no_default:
         if axis == 0:
             index = mapper
         else:
             columns = mapper
-    op = DataFrameRenameAxis(index=index, columns=columns, copy_value=copy, level=level)
+    op = DataFrameRenameAxis(
+        index=None if index is no_default else index,
+        columns=None if columns is no_default else columns,
+        copy_value=copy,
+        level=level,
+        axis=0 if index is not no_default else 1,
+    )
     result = op(df_or_series)
     if not inplace:
         return result
@@ -92,9 +100,9 @@ def rename_axis_with_level(
 
 def rename_axis(
     df_or_series,
-    mapper=None,
-    index=None,
-    columns=None,
+    mapper=no_default,
+    index=no_default,
+    columns=no_default,
     axis=0,
     copy=True,
     inplace=False,

maxframe/dataframe/indexing/reset_index.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");

maxframe/dataframe/indexing/sample.py

@@ -13,11 +13,12 @@
 # limitations under the License.
 
 import copy
+from typing import List
 
 import numpy as np
 
 from ... import opcodes
-from ...core import ENTITY_TYPE, get_output_types
+from ...core import ENTITY_TYPE, EntityData, get_output_types
 from ...serialization.serializables import (
     AnyField,
     BoolField,
@@ -46,23 +47,23 @@ class DataFrameSample(DataFrameOperator, DataFrameOperatorMixin):
             random_state = np.random.RandomState(seed)
         super().__init__(random_state=random_state, seed=seed, **kw)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameSample", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
         it = iter(inputs)
         next(it)
-        if isinstance(self.weights, ENTITY_TYPE):
-            self.weights = next(it)
+        if isinstance(op.weights, ENTITY_TYPE):
+            op.weights = next(it)
 
     def __call__(self, df):
         params = df.params
         new_shape = list(df.shape)
 
-        if self.frac is not None and not np.isnan(df.shape[self.axis]):
-            self.size = int(self.frac * df.shape[self.axis])
-            self.frac = None
-
         if self.size is not None:
             new_shape[self.axis] = self.size
+        elif self.frac is not None:
+            new_shape[self.axis] = np.nan
+
         params["shape"] = tuple(new_shape)
         params["index_value"] = parse_index(df.index_value.to_pandas()[:0])
 
@@ -196,6 +197,9 @@ def sample(
     falcon         2          2                 10
     fish           0          0                  8
     """
+    if frac and n:
+        raise ValueError("Please enter a value for `frac` OR `n`, not both.")
+
     axis = validate_axis(axis or 0, df_or_series)
     if axis == 1:
         raise NotImplementedError("Currently cannot sample over columns")

maxframe/dataframe/indexing/set_axis.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 ENTITY_TYPE, get_output_types
+from ...core import ENTITY_TYPE, EntityData, get_output_types
 from ...serialization.serializables import AnyField, Int8Field, KeyField
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import parse_index, validate_axis
@@ -29,11 +31,12 @@ class DataFrameSetAxis(DataFrameOperator, DataFrameOperatorMixin):
     axis = Int8Field("axis", default=None)
     value = AnyField("value", default=None)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self.input = inputs[0]
-        if isinstance(self.value, ENTITY_TYPE):
-            self.value = inputs[-1]
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameSetAxis", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.input = inputs[0]
+        if isinstance(op.value, ENTITY_TYPE):
+            op.value = inputs[-1]
 
     def __call__(self, df_or_series):
         new_size = self.value.shape[0]

maxframe/dataframe/indexing/setitem.py

@@ -12,12 +12,14 @@
 # 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 pandas.api.types import is_list_like
 
 from ... import opcodes
-from ...core import OutputType
+from ...core import EntityData, OutputType
 from ...serialization.serializables import AnyField, KeyField
 from ...tensor.core import TENSOR_TYPE
 from ...utils import pd_release_version
@@ -43,11 +45,12 @@ class DataFrameSetitem(DataFrameOperator, DataFrameOperatorMixin):
         if self.output_types is None:
             self.output_types = [OutputType.dataframe]
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self.target = self._inputs[0]
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameSetitem", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.target = op._inputs[0]
         if len(inputs) > 1:
-            self.value = self._inputs[-1]
+            op.value = op._inputs[-1]
 
     @staticmethod
     def _is_scalar_tensor(t):

maxframe/dataframe/indexing/where.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 ENTITY_TYPE
+from ...core import ENTITY_TYPE, EntityData
 from ...serialization.serializables import AnyField, BoolField, Int32Field, StringField
 from ...tensor.utils import filter_inputs
 from ..core import DATAFRAME_TYPE, SERIES_TYPE
@@ -99,14 +101,15 @@ class DataFrameWhere(DataFrameOperator, DataFrameOperatorMixin):
                 index_value=df_or_series.index_value,
             )
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs)
-        self._input = next(inputs_iter)
-        if isinstance(self.cond, ENTITY_TYPE):
-            self.cond = next(inputs_iter)
-        if isinstance(self.other, ENTITY_TYPE):
-            self.other = next(inputs_iter)
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameWhere", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs)
+        op._input = next(inputs_iter)
+        if isinstance(op.cond, ENTITY_TYPE):
+            op.cond = next(inputs_iter)
+        if isinstance(op.other, ENTITY_TYPE):
+            op.other = next(inputs_iter)
 
 
 _doc_template = """

maxframe/dataframe/merge/__init__.py

@@ -16,7 +16,6 @@ from .append import DataFrameAppend, append
 from .concat import DataFrameConcat, concat
 from .merge import (
     DataFrameMerge,
-    DataFrameMergeAlign,
     DistributedMapJoinHint,
     MapJoinHint,
     SkewJoinHint,

maxframe/dataframe/merge/concat.py

@@ -17,7 +17,7 @@ from typing import List, Union
 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,
@@ -256,45 +256,24 @@ class GroupByConcat(DataFrameOperator, DataFrameOperatorMixin):
     def groupby_params(self):
         return self._groupby_params
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        inputs_iter = iter(self._inputs)
+    @classmethod
+    def _set_inputs(cls, op: "GroupByConcat", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        inputs_iter = iter(op._inputs)
 
         new_groups = []
-        for _ in self._groups:
+        for _ in op._groups:
             new_groups.append(next(inputs_iter))
-        self._groups = new_groups
+        op._groups = new_groups
 
-        if isinstance(self._groupby_params["by"], list):
+        if isinstance(op._groupby_params["by"], list):
             by = []
-            for v in self._groupby_params["by"]:
+            for v in op._groupby_params["by"]:
                 if isinstance(v, ENTITY_TYPE):
                     by.append(next(inputs_iter))
                 else:
                     by.append(v)
-            self._groupby_params["by"] = by
-
-    @classmethod
-    def execute(cls, ctx, op):
-        input_data = [ctx[input.key] for input in op.groups]
-        obj = pd.concat([d.obj for d in input_data])
-
-        params = op.groupby_params.copy()
-        if isinstance(params["by"], list):
-            by = []
-            for v in params["by"]:
-                if isinstance(v, ENTITY_TYPE):
-                    by.append(ctx[v.key])
-                else:
-                    by.append(v)
-            params["by"] = by
-        selection = params.pop("selection", None)
-
-        result = obj.groupby(**params)
-        if selection:
-            result = result[selection]
-
-        ctx[op.outputs[0].key] = result
+            op._groupby_params["by"] = by
 
 
 def concat(

maxframe/dataframe/merge/merge.py

@@ -22,13 +22,11 @@ from pandas import Index
 
 from ... import opcodes
 from ...core import OutputType
-from ...core.operator import MapReduceOperator
 from ...serialization.serializables import (
     AnyField,
     BoolField,
     DictField,
     Int32Field,
-    KeyField,
     NamedTupleField,
     Serializable,
     StringField,
@@ -53,26 +51,6 @@ DEFAULT_BLOOM_FILTER_ON = "large"
 
 cudf = lazy_import("cudf")
 
-
-class DataFrameMergeAlign(MapReduceOperator, DataFrameOperatorMixin):
-    _op_type_ = opcodes.DATAFRAME_SHUFFLE_MERGE_ALIGN
-
-    index_shuffle_size = Int32Field("index_shuffle_size")
-    shuffle_on = AnyField("shuffle_on")
-
-    input = KeyField("input")
-    # for mapper
-    mapper_id = Int32Field("mapper_id", default=0)
-
-    def __init__(self, output_types=None, **kw):
-        super().__init__(_output_types=output_types, **kw)
-        self._output_types = output_types
-
-    @property
-    def output_limit(self) -> int:
-        return len(self.output_types)
-
-
 MergeSplitInfo = namedtuple("MergeSplitInfo", "split_side, split_index, nsplits")
 
 
@@ -300,8 +278,8 @@ class DataFrameMerge(DataFrameOperator, DataFrameOperatorMixin):
     left_hint = AnyField("left_hint", default=None)
     right_hint = AnyField("right_hint", default=None)
 
-    def __init__(self, copy=None, **kwargs):
-        super().__init__(copy_=copy, **kwargs)
+    def __init__(self, copy=None, output_types=None, **kwargs):
+        super().__init__(copy_=copy, _output_types=output_types, **kwargs)
 
     def __call__(self, left, right):
         empty_left, empty_right = build_df(left), build_df(right)

maxframe/dataframe/misc/__init__.py

@@ -38,8 +38,10 @@ from .map import index_map, series_map
 from .melt import melt
 from .memory_usage import df_memory_usage, index_memory_usage, series_memory_usage
 from .pct_change import pct_change
+from .pivot import pivot
 from .pivot_table import pivot_table
 from .qcut import qcut
+from .rechunk import rechunk
 from .select_dtypes import select_dtypes
 from .shift import shift, tshift
 from .stack import stack
@@ -68,9 +70,11 @@ def _install():
         setattr(t, "melt", melt)
         setattr(t, "memory_usage", df_memory_usage)
         setattr(t, "pct_change", pct_change)
+        setattr(t, "pivot", pivot)
         setattr(t, "pivot_table", pivot_table)
         setattr(t, "pop", df_pop)
         setattr(t, "query", df_query)
+        setattr(t, "rechunk", rechunk)
         setattr(t, "select_dtypes", select_dtypes)
         setattr(t, "shift", shift)
         setattr(t, "stack", stack)
@@ -96,6 +100,7 @@ def _install():
         setattr(t, "map", series_map)
         setattr(t, "memory_usage", series_memory_usage)
         setattr(t, "pct_change", pct_change)
+        setattr(t, "rechunk", rechunk)
         setattr(t, "shift", shift)
         setattr(t, "transform", series_transform)
         setattr(t, "tshift", tshift)
@@ -112,6 +117,7 @@ def _install():
         setattr(t, "is_monotonic_decreasing", property(fget=is_monotonic_decreasing))
         setattr(t, "map", index_map)
         setattr(t, "memory_usage", index_memory_usage)
+        setattr(t, "rechunk", rechunk)
         setattr(t, "value_counts", value_counts)
 
 

maxframe/dataframe/misc/_duplicate.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 pandas.api.types import is_list_like
 
+from ...core import EntityData
 from ...core.operator import MapReduceOperator
 from ...serialization.serializables import AnyField, KeyField, StringField
 from ..operators import DataFrameOperatorMixin
@@ -26,9 +29,10 @@ class DuplicateOperand(MapReduceOperator, DataFrameOperatorMixin):
     keep = AnyField("keep", default="first")
     method = StringField("method", default=None)
 
-    def _set_inputs(self, inputs):
-        super()._set_inputs(inputs)
-        self.input = self._inputs[0]
+    @classmethod
+    def _set_inputs(cls, op: "DuplicateOperand", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.input = op._inputs[0]
 
 
 def validate_subset(df, subset):