maxframe 2.0.0b2__cp38-cp38-win_amd64.whl → 2.2.0__cp38-cp38-win_amd64.whl

maxframe/dataframe/datasource/from_index.py

@@ -51,7 +51,7 @@ class SeriesFromIndex(DataFrameOperator, DataFrameOperatorMixin):
 
 
 def series_from_index(ind, index=None, name=None):
-    name = name or ind.name or 0
+    name = name or ind.name
     if index is not None:
         index = Index(index)
     op = SeriesFromIndex(input_=ind, index=index, name=name)

maxframe/dataframe/datasource/from_records.py

@@ -77,6 +77,83 @@ def from_records(
     sparse=False,
     **kw
 ):
+    """
+    Convert structured or record ndarray to DataFrame.
+
+    Creates a DataFrame object from a structured ndarray, sequence of
+    tuples or dicts, or DataFrame.
+
+    Parameters
+    ----------
+    data : structured ndarray, sequence of tuples or dicts, or DataFrame
+        Structured input data.
+
+        .. deprecated:: 2.1.0
+            Passing a DataFrame is deprecated.
+    index : str, list of fields, array-like
+        Field of array to use as the index, alternately a specific set of
+        input labels to use.
+    exclude : sequence, default None
+        Columns or fields to exclude.
+    columns : sequence, default None
+        Column names to use. If the passed data do not have names
+        associated with them, this argument provides names for the
+        columns. Otherwise this argument indicates the order of the columns
+        in the result (any names not found in the data will become all-NA
+        columns).
+    coerce_float : bool, default False
+        Attempt to convert values of non-string, non-numeric objects (like
+        decimal.Decimal) to floating point, useful for SQL result sets.
+    nrows : int, default None
+        Number of rows to read if data is an iterator.
+
+    Returns
+    -------
+    DataFrame
+
+    See Also
+    --------
+    DataFrame.from_dict : DataFrame from dict of array-like or dicts.
+    DataFrame : DataFrame object creation using constructor.
+
+    Examples
+    --------
+    Data can be provided as a structured ndarray:
+
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> data = mt.array([(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')],
+    ...                 dtype=[('col_1', 'i4'), ('col_2', 'U1')])
+    >>> md.DataFrame.from_records(data).execute()
+       col_1 col_2
+    0      3     a
+    1      2     b
+    2      1     c
+    3      0     d
+
+    Data can be provided as a list of dicts:
+
+    >>> data = [{'col_1': 3, 'col_2': 'a'},
+    ...         {'col_1': 2, 'col_2': 'b'},
+    ...         {'col_1': 1, 'col_2': 'c'},
+    ...         {'col_1': 0, 'col_2': 'd'}]
+    >>> md.DataFrame.from_records(data).execute()
+       col_1 col_2
+    0      3     a
+    1      2     b
+    2      1     c
+    3      0     d
+
+    Data can be provided as a list of tuples with corresponding columns:
+
+    >>> data = [(3, 'a'), (2, 'b'), (1, 'c'), (0, 'd')]
+    >>> md.DataFrame.from_records(data, columns=['col_1', 'col_2']).execute()
+       col_1 col_2
+    0      3     a
+    1      2     b
+    2      1     c
+    3      0     d
+    """
     if isinstance(data, np.ndarray):
         from .dataframe import from_pandas
 

maxframe/dataframe/datasource/from_tensor.py

@@ -39,6 +39,7 @@ class DataFrameFromTensor(DataFrameOperator, DataFrameOperatorMixin):
     input = AnyField("input")
     index = AnyField("index")
     columns = AnyField("columns")
+    axis = AnyField("axis")
 
     def __init__(self, *args, **kwargs):
         kwargs["_output_types"] = [OutputType.dataframe]
@@ -120,46 +121,82 @@ class DataFrameFromTensor(DataFrameOperator, DataFrameOperatorMixin):
             if isinstance(tileable, ENTITY_TYPE):
                 tileables.append(tileable)
 
-        if index is not None:
-            tileable_size = tileables[0].shape[0]
-            if hasattr(index, "shape"):
-                index_size = index.shape[0]
+        if self.axis == 0:
+            if index is not None:
+                raise NotImplementedError("Cannot accept index when axis=0")
             else:
-                index_size = len(index)
-            if (
-                not pd.isna(tileable_size)
-                and not pd.isna(index_size)
-                and tileable_size != index_size
-            ):
-                raise ValueError(
-                    f"index {index} should have the same shape "
-                    f"with tensor: {tileable_size}"
-                )
-            index_value = self._process_index(index, tileables)
+                index = pd.Index(list(input_1d_tileables.keys()))
+                index_value = parse_index(index, store_data=True)
+                self.index = index
+
+            if columns is not None:
+                tileable_size = tileables[0].shape[0] if tileables else 0
+                if not isinstance(columns, pd.Index):
+                    columns = self.columns = pd.Index(columns)
+                column_size = columns.shape[0]
+                if (
+                    not pd.isna(tileable_size)
+                    and not pd.isna(column_size)
+                    and tileable_size != column_size
+                ):
+                    raise ValueError(
+                        f"columns {columns} should have the same shape "
+                        f"with tensor: {tileable_size}"
+                    )
+                columns_value = self._process_index(columns, tileables)
+            else:
+                if not tileables or np.isnan(tileables[0].shape[0]):
+                    columns = columns_value = None
+                else:
+                    columns = pd.RangeIndex(0, tileables[0].shape[0])
+                    columns_value = parse_index(columns, store_data=True)
+                self.columns = columns
+
+            shape = (len(input_1d_tileables), shape[0] if shape else 0)
         else:
-            if np.isnan(tileables[0].shape[0]):
-                index = pd.RangeIndex(0)
+            if index is not None:
+                tileable_size = tileables[0].shape[0] if tileables else 0
+                if hasattr(index, "shape"):
+                    index_size = index.shape[0]
+                else:
+                    index_size = len(index)
+                if (
+                    not pd.isna(tileable_size)
+                    and not pd.isna(index_size)
+                    and tileable_size != index_size
+                ):
+                    raise ValueError(
+                        f"index {index} should have the same shape "
+                        f"with tensor: {tileable_size}"
+                    )
+                index_value = self._process_index(index, tileables)
             else:
-                index = pd.RangeIndex(0, tileables[0].shape[0])
-            self.index = index
-            index_value = parse_index(index)
+                if not tileables or np.isnan(tileables[0].shape[0]):
+                    index = pd.RangeIndex(0)
+                else:
+                    index = pd.RangeIndex(0, tileables[0].shape[0])
+                self.index = index
+                index_value = parse_index(index)
 
-        if columns is not None:
-            if len(input_1d_tileables) != len(columns):
-                raise ValueError(
-                    f"columns {columns} should have size {len(input_1d_tileables)}"
+            if columns is not None:
+                if len(input_1d_tileables) != len(columns):
+                    raise ValueError(
+                        f"columns {columns} should have size {len(input_1d_tileables)}"
+                    )
+                if not isinstance(columns, pd.Index):
+                    if isinstance(columns, ENTITY_TYPE):
+                        raise NotImplementedError(
+                            "The columns value cannot be a tileable"
+                        )
+                    columns = pd.Index(columns)
+                columns_value = parse_index(columns, store_data=True)
+            else:
+                columns_value = parse_index(
+                    pd.RangeIndex(0, len(input_1d_tileables)), store_data=True
                 )
-            if not isinstance(columns, pd.Index):
-                if isinstance(columns, ENTITY_TYPE):
-                    raise NotImplementedError("The columns value cannot be a tileable")
-                columns = pd.Index(columns)
-            columns_value = parse_index(columns, store_data=True)
-        else:
-            columns_value = parse_index(
-                pd.RangeIndex(0, len(input_1d_tileables)), store_data=True
-            )
 
-        shape = (shape[0], len(input_1d_tileables))
+            shape = (shape[0] if shape else 0, len(input_1d_tileables))
+
         return self.new_dataframe(
             tileables,
             shape,
@@ -278,6 +315,9 @@ def dataframe_from_tensor(
     gpu: bool = None,
     sparse: bool = False,
 ):
+    if isinstance(columns, list) and columns and isinstance(columns[0], tuple):
+        columns = pd.MultiIndex.from_tuples(columns)
+
     if tensor is not None:
         if tensor.ndim > 2 or tensor.ndim <= 0:
             raise TypeError(
@@ -299,6 +339,8 @@ def dataframe_from_tensor(
             dtypes = pd.Series([], index=pd.Index([], dtype=object))
     if index is not None and not isinstance(index, ENTITY_TYPE):
         index = pd.Index(index)
+        if isinstance(index[0], tuple):
+            index = pd.MultiIndex.from_tuples(index)
     op = DataFrameFromTensor(
         input=tensor, index=index, columns=columns, gpu=gpu, sparse=sparse
     )
@@ -311,7 +353,10 @@ def dataframe_from_1d_tileables(
     columns: Union[pd.Index, list] = None,
     gpu: bool = None,
     sparse: bool = False,
+    axis: int = 1,
 ):
+    from pandas.core.dtypes.cast import find_common_type
+
     data = dict()
     for k, v in d.items():
         if isinstance(v, (list, tuple)) and any(
@@ -322,9 +367,9 @@ def dataframe_from_1d_tileables(
             data[k] = v
     d = data
     if columns is not None:
-        tileables = [d.get(c) for c in columns]
+        tileables = [d.get(c) for c in columns] if axis == 1 else list(d.values())
     else:
-        columns = list(d.keys())
+        columns = list(d.keys()) if axis == 1 else None
         tileables = list(d.values())
 
     gpu = (
@@ -332,14 +377,37 @@ def dataframe_from_1d_tileables(
         if gpu is None
         else gpu
     )
-    dtypes = pd.Series(
-        [t.dtype if hasattr(t, "dtype") else pd.Series(t).dtype for t in tileables],
-        index=columns,
-    )
+
+    if axis == 0:
+        col_num = (
+            tileables[0].shape[0]
+            if hasattr(tileables[0], "shape")
+            else len(tileables[0])
+        )
+        if pd.isna(col_num):
+            dtypes = None
+        else:
+            common_dtype = find_common_type(
+                [
+                    t.dtype if hasattr(t, "dtype") else pd.Series(t).dtype
+                    for t in tileables
+                ]
+            )
+            dtypes = pd.Series(
+                [common_dtype] * col_num,
+                index=columns if columns is not None else pd.RangeIndex(col_num),
+            )
+    else:
+        dtypes = pd.Series(
+            [t.dtype if hasattr(t, "dtype") else pd.Series(t).dtype for t in tileables],
+            index=columns,
+        )
+
     if index is not None and not isinstance(index, ENTITY_TYPE):
         index = pd.Index(index)
+
     op = DataFrameFromTensor(
-        input=d, index=index, columns=columns, gpu=gpu, sparse=sparse
+        input=d, index=index, columns=columns, gpu=gpu, sparse=sparse, axis=axis
     )
     return op(d, index, columns, dtypes)
 

maxframe/dataframe/datasource/read_csv.py

@@ -441,13 +441,12 @@ def read_csv(
     Examples
     --------
     >>> import maxframe.dataframe as md
-    >>> from maxframe.lib.filesystem.oss import build_oss_path
     >>> md.read_csv('data.csv')  # doctest: +SKIP
     >>> # read from HDFS
     >>> md.read_csv('hdfs://localhost:8020/test.csv')  # doctest: +SKIP
     >>> # read from OSS
-    >>> auth_path = build_oss_path(file_path, access_key_id, access_key_secret, end_point)
-    >>> md.read_csv(auth_path)
+    >>> md.read_csv('oss://oss-cn-hangzhou-internal.aliyuncs.com/bucket/test.csv',
+    >>>             storage_options={'role_arn': 'acs:ram::xxxxxx:role/aliyunodpsdefaultrole'})
     """
     # infer dtypes and columns
     if isinstance(path, (list, tuple)):

maxframe/dataframe/datasource/tests/test_datasource.py

@@ -184,6 +184,23 @@ def test_from_tensor():
     df = dataframe_from_1d_tileables(d)
     pd.testing.assert_index_equal(df.columns_value.to_pandas(), pd.RangeIndex(2))
 
+    # test axis parameter for dataframe_from_1d_tileables
+    d = OrderedDict(
+        [("a", mt.tensor(np.random.rand(4))), ("b", mt.tensor(np.random.rand(4)))]
+    )
+
+    # axis=1 (default behavior) - keys become columns
+    df = dataframe_from_1d_tileables(d, axis=1)
+    assert df.shape == (4, 2)
+    pd.testing.assert_index_equal(df.columns_value.to_pandas(), pd.Index(["a", "b"]))
+    pd.testing.assert_index_equal(df.index_value.to_pandas(), pd.RangeIndex(4))
+
+    # axis=0 - keys become index (rows)
+    df = dataframe_from_1d_tileables(d, axis=0)
+    assert df.shape == (2, 4)
+    pd.testing.assert_index_equal(df.index_value.to_pandas(), pd.Index(["a", "b"]))
+    pd.testing.assert_index_equal(df.columns_value.to_pandas(), pd.RangeIndex(4))
+
     series = series_from_tensor(mt.random.rand(4))
     pd.testing.assert_index_equal(series.index_value.to_pandas(), pd.RangeIndex(4))
 
@@ -207,6 +224,26 @@ def test_from_tensor():
     with pytest.raises(ValueError):
         dataframe_from_tensor(mt.random.rand(4, 3), columns=["a", "b"])
 
+    # 1-d tensors should have same shape
+    with pytest.raises(ValueError):
+        dataframe_from_1d_tileables(
+            OrderedDict(
+                [(0, mt.tensor(np.random.rand(3))), (1, mt.tensor(np.random.rand(2)))]
+            )
+        )
+
+    # index has wrong shape
+    with pytest.raises(ValueError):
+        dataframe_from_1d_tileables(
+            {0: mt.tensor(np.random.rand(3))}, index=mt.tensor(np.random.rand(2))
+        )
+
+    # columns have wrong shape
+    with pytest.raises(ValueError):
+        dataframe_from_1d_tileables(
+            {0: mt.tensor(np.random.rand(3))}, columns=["a", "b"]
+        )
+
     # index should be 1-d
     with pytest.raises(ValueError):
         dataframe_from_tensor(

maxframe/dataframe/datastore/__init__.py

@@ -12,14 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .to_csv import to_csv
 from .to_odps import to_odps_table
 
 
 def _install():
-    from ..core import DATAFRAME_TYPE
+    from ..core import DATAFRAME_TYPE, SERIES_TYPE
 
     for t in DATAFRAME_TYPE:
+        t.to_csv = to_csv
         t.to_odps_table = to_odps_table
+    for t in SERIES_TYPE:
+        t.to_csv = to_csv
 
 
 _install()

maxframe/dataframe/datastore/to_csv.py

@@ -12,17 +12,13 @@
 # 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,
     BoolField,
     DictField,
     Int32Field,
     Int64Field,
-    KeyField,
     ListField,
     StringField,
 )
@@ -33,27 +29,26 @@ from .core import DataFrameDataStore
 class DataFrameToCSV(DataFrameDataStore):
     _op_type_ = opcodes.TO_CSV
 
-    input = KeyField("input")
-    path = AnyField("path")
-    sep = StringField("sep")
-    na_rep = StringField("na_rep")
-    float_format = StringField("float_format")
-    columns = ListField("columns")
-    header = AnyField("header")
-    index = BoolField("index")
-    index_label = AnyField("index_label")
-    mode = StringField("mode")
-    encoding = StringField("encoding")
-    compression = AnyField("compression")
-    quoting = Int32Field("quoting")
-    quotechar = StringField("quotechar")
-    line_terminator = StringField("line_terminator")
-    chunksize = Int64Field("chunksize")
-    date_format = StringField("date_format")
-    doublequote = BoolField("doublequote")
-    escapechar = StringField("escapechar")
-    decimal = StringField("decimal")
-    storage_options = DictField("storage_options")
+    path = AnyField("path", default=None)
+    sep = StringField("sep", default=None)
+    na_rep = StringField("na_rep", default=None)
+    float_format = StringField("float_format", default=None)
+    columns = ListField("columns", default=None)
+    header = AnyField("header", default=None)
+    index = BoolField("index", default=None)
+    index_label = AnyField("index_label", default=None)
+    mode = StringField("mode", default=None)
+    encoding = StringField("encoding", default=None)
+    compression = AnyField("compression", default=None)
+    quoting = Int32Field("quoting", default=None)
+    quotechar = StringField("quotechar", default=None)
+    line_terminator = StringField("line_terminator", default=None)
+    chunksize = Int64Field("chunksize", default=None)
+    date_format = StringField("date_format", default=None)
+    doublequote = BoolField("doublequote", default=None)
+    escapechar = StringField("escapechar", default=None)
+    decimal = StringField("decimal", default=None)
+    storage_options = DictField("storage_options", default=None)
 
     def __init__(self, output_types=None, **kw):
         super().__init__(_output_types=output_types, **kw)
@@ -63,19 +58,6 @@ class DataFrameToCSV(DataFrameDataStore):
         # if wildcard in path, write csv into multiple files
         return "*" not in self.path
 
-    @property
-    def output_stat(self):
-        return self.output_stat
-
-    @property
-    def output_limit(self):
-        return 1 if not self.output_stat else 2
-
-    @classmethod
-    def _set_inputs(cls, op: "DataFrameToCSV", inputs: List[EntityData]):
-        super()._set_inputs(op, inputs)
-        op._input = op._inputs[0]
-
     def __call__(self, df):
         index_value = parse_index(df.index_value.to_pandas()[:0], df)
         if df.ndim == 2:
@@ -110,13 +92,14 @@ def to_csv(
     compression="infer",
     quoting=None,
     quotechar='"',
-    line_terminator=None,
+    lineterminator=None,
     chunksize=None,
     date_format=None,
     doublequote=True,
     escapechar=None,
     decimal=".",
     storage_options=None,
+    **kw,
 ):
     r"""
     Write object to a comma-separated values (csv) file.
@@ -169,7 +152,7 @@ def to_csv(
         will treat them as non-numeric.
     quotechar : str, default '\"'
         String of length 1. Character used to quote fields.
-    line_terminator : str, optional
+    lineterminator : str, optional
         The newline character or character sequence to use in the output
         file. Defaults to `os.linesep`, which depends on the OS in which
         this method is called ('\n' for linux, '\r\n' for Windows, i.e.).
@@ -203,6 +186,11 @@ def to_csv(
     ...                    'weapon': ['sai', 'bo staff']})
     >>> df.to_csv('out.csv', index=False).execute()
     """
+    lineterminator = lineterminator or kw.pop("line_terminator", None)
+    if kw:
+        raise TypeError(
+            f"to_csv() got an unexpected keyword argument '{next(iter(kw))}'"
+        )
 
     if mode != "w":  # pragma: no cover
         raise NotImplementedError("only support to_csv with mode 'w' for now")
@@ -220,7 +208,7 @@ def to_csv(
         compression=compression,
         quoting=quoting,
         quotechar=quotechar,
-        line_terminator=line_terminator,
+        line_terminator=lineterminator,
         chunksize=chunksize,
         date_format=date_format,
         doublequote=doublequote,

maxframe/dataframe/datastore/to_odps.py

@@ -56,6 +56,7 @@ class DataFrameToODPSTable(DataFrameDataStore):
     index_label = ListField("index_label", FieldTypes.string, default=None)
     lifecycle = Int64Field("lifecycle", default=None)
     table_properties = DictField("table_properties", default=None)
+    primary_key = ListField("primary_key", FieldTypes.string, default=None)
 
     def __init__(self, **kw):
         super().__init__(_output_types=[OutputType.dataframe], **kw)
@@ -100,11 +101,12 @@ def to_odps_table(
     partition: Optional[str] = None,
     partition_col: Union[None, str, List[str]] = None,
     overwrite: bool = False,
-    unknown_as_string: Optional[bool] = None,
+    unknown_as_string: Optional[bool] = True,
     index: bool = True,
     index_label: Union[None, str, List[str]] = None,
     lifecycle: Optional[int] = None,
     table_properties: Optional[dict] = None,
+    primary_key: Union[None, str, List[str]] = None,
 ):
     """
     Write DataFrame object into a MaxCompute (ODPS) table.
@@ -145,6 +147,10 @@ def to_odps_table(
         Specify lifecycle of the output table.
     table_properties: Optional[dict]
         Specify properties of the output table.
+    primary_key: Union[None, str, List[str]]
+        If provided and target table does not exist, target table
+        will be a delta table with columns specified in this argument
+        as primary key.
 
     Returns
     -------
@@ -201,12 +207,14 @@ def to_odps_table(
         index_table_intersect = index_cols & table_cols
         if index_table_intersect:
             raise ValueError(
-                f"Index column(s) {index_table_intersect} conflict with column(s) of the input dataframe."
+                f"Index column(s) {index_table_intersect} conflict with "
+                f"column(s) of the input dataframe."
             )
         index_partition_intersect = index_cols & partition_col_set
         if index_partition_intersect:
             raise ValueError(
-                f"Index column(s) {index_partition_intersect} conflict with partition column(s)."
+                f"Index column(s) {index_partition_intersect} conflict "
+                f"with partition column(s)."
             )
 
     if partition_col:
@@ -217,6 +225,23 @@ def to_odps_table(
                 " is not the data column(s) of the input dataframe."
             )
 
+    table_properties = table_properties or {}
+    if primary_key is not None:
+        table_properties["transactional"] = "true"
+    if odps_entry.exist_table(table):
+        table_obj = odps_entry.get_table(table)
+        if table_obj.is_transactional:
+            table_properties = table_properties or {}
+            table_properties["transactional"] = "true"
+            primary_key = primary_key or table_obj.primary_key or ()
+            if set(primary_key) != set(table_obj.primary_key or ()):
+                raise ValueError(
+                    f"Primary keys between existing table {table} and "
+                    f"provided arguments are not same."
+                )
+    if primary_key and not isinstance(primary_key, (list, tuple)):
+        primary_key = [primary_key]
+
     op = DataFrameToODPSTable(
         dtypes=df.dtypes,
         table_name=table,
@@ -227,6 +252,7 @@ def to_odps_table(
         index=index,
         index_label=index_label,
         lifecycle=lifecycle or options.session.table_lifecycle,
-        table_properties=table_properties,
+        table_properties=table_properties or None,
+        primary_key=primary_key or None,
     )
     return op(df)

maxframe/dataframe/extensions/__init__.py

@@ -24,20 +24,36 @@ from .apply_chunk import (
     df_apply_chunk,
     series_apply_chunk,
 )
+from .cartesian_chunk import cartesian_chunk
+from .collect_kv import collect_kv
+from .extract_kv import extract_kv
 from .flatjson import series_flatjson
 from .flatmap import df_flatmap, series_flatmap
+from .map_reduce import map_reduce
+from .rebalance import DataFrameRebalance, rebalance
 from .reshuffle import DataFrameReshuffle, df_reshuffle
 
 
 def _install():
     from ..core import DATAFRAME_TYPE, INDEX_TYPE, SERIES_TYPE
 
-    DataFrameMaxFrameAccessor._register("reshuffle", df_reshuffle)
-    DataFrameMaxFrameAccessor._register("flatmap", df_flatmap)
     DataFrameMaxFrameAccessor._register("apply_chunk", df_apply_chunk)
-    SeriesMaxFrameAccessor._register("flatmap", series_flatmap)
-    SeriesMaxFrameAccessor._register("flatjson", series_flatjson)
+    DataFrameMaxFrameAccessor._register("cartesian_chunk", cartesian_chunk)
+    DataFrameMaxFrameAccessor._register("collect_kv", collect_kv)
+    DataFrameMaxFrameAccessor._register("extract_kv", extract_kv)
+    DataFrameMaxFrameAccessor._register("flatmap", df_flatmap)
+    DataFrameMaxFrameAccessor._register("map_reduce", map_reduce)
+    DataFrameMaxFrameAccessor._register("rebalance", rebalance)
+    DataFrameMaxFrameAccessor._register("reshuffle", df_reshuffle)
+
     SeriesMaxFrameAccessor._register("apply_chunk", series_apply_chunk)
+    SeriesMaxFrameAccessor._register("cartesian_chunk", cartesian_chunk)
+    SeriesMaxFrameAccessor._register("extract_kv", extract_kv)
+    SeriesMaxFrameAccessor._register("flatjson", series_flatjson)
+    SeriesMaxFrameAccessor._register("flatmap", series_flatmap)
+    SeriesMaxFrameAccessor._register("rebalance", rebalance)
+
+    IndexMaxFrameAccessor._register("rebalance", rebalance)
 
     if DataFrameMaxFrameAccessor._api_count:
         for t in DATAFRAME_TYPE: