maxframe 2.4.0rc1__cp312-cp312-win32.whl

maxframe/dataframe/datastore/to_json.py

@@ -0,0 +1,215 @@
+# 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.
+
+from typing import Any, Dict, Optional, Union
+
+from ... import opcodes
+from ...serialization.serializables import AnyField, BoolField, DictField, StringField
+from ..utils import parse_index
+from .core import LakeDataStore
+
+
+class DataFrameToJSON(LakeDataStore):
+    _op_type_ = opcodes.TO_JSON
+
+    orient = StringField("orient", default=None)
+    default_handler = AnyField("default_handler", default=None)
+    lines = BoolField("lines", default=None)
+    index = BoolField("index", default=None)
+    json_kwargs = DictField("json_kwargs", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    @property
+    def one_file(self):
+        # if wildcard in path, write json into multiple files
+        return "*" not in self.path and not self.partition_cols
+
+    def __call__(self, df):
+        if self.one_file and (self.orient != "records" or not self.lines):
+            raise ValueError(
+                "You can only fix one single output file when orient='records' and lines is True"
+            )
+        index_value = parse_index(df.index_value.to_pandas()[:0], df)
+        if df.ndim == 2:
+            columns_value = parse_index(
+                df.columns_value.to_pandas()[:0], store_data=True
+            )
+            return self.new_dataframe(
+                [df],
+                shape=(0, 0),
+                dtypes=df.dtypes[:0],
+                index_value=index_value,
+                columns_value=columns_value,
+            )
+        else:
+            return self.new_series(
+                [df], shape=(0,), dtype=df.dtype, index_value=index_value
+            )
+
+
+def to_json(
+    df,
+    path: Optional[str] = None,
+    orient: Optional[str] = None,
+    date_format: Optional[str] = None,
+    double_precision: int = 10,
+    force_ascii: bool = True,
+    date_unit: Optional[str] = "ms",
+    default_handler: Optional[callable] = None,
+    lines: bool = False,
+    compression: Union[str, Dict[str, Any], None] = "infer",
+    index: Optional[bool] = None,
+    indent: Optional[int] = None,
+    storage_options: Optional[Dict[str, Any]] = None,
+    partition_cols: Optional[Union[str, list]] = None,
+    **kwargs,
+):
+    r"""
+    Convert the object to a JSON string.
+
+    Note NaN's and None will be converted to null and datetime objects
+    will be converted to UNIX timestamps.
+
+    Parameters
+    ----------
+    path : str, path object, file-like object, or None, default None
+        String, path object (implementing os.PathLike[str]), or file-like
+        object implementing a write() function. If None, the result is
+        returned as a string.
+    orient : str
+        Indication of expected JSON string format.
+
+        * Series:
+
+            - default is 'index'
+            - allowed values are: {'split', 'records', 'index', 'table'}.
+
+        * DataFrame:
+
+            - default is 'columns'
+            - allowed values are: {'split', 'records', 'index', 'columns',
+              'values', 'table'}.
+
+        * The format of the JSON string:
+
+            - 'split' : dict like {'index' -> [index], 'columns' -> [columns],
+              'data' -> [values]}
+            - 'records' : list like [{column -> value}, ... , {column -> value}]
+            - 'index' : dict like {index -> {column -> value}}
+            - 'columns' : dict like {column -> {index -> value}}
+            - 'values' : just the values array
+            - 'table' : dict like {'schema': {schema}, 'data': {data}}
+
+            Describing the data, where data component is like ``orient='records'``.
+
+    date_format : {None, 'epoch', 'iso'}
+        Type of date conversion. 'epoch' = epoch milliseconds,
+        'iso' = ISO8601. The default depends on the `orient`. For
+        ``orient='table'``, the default is 'iso'. For all other orients,
+        the default is 'epoch'.
+    double_precision : int, default 10
+        The number of decimal places to use when encoding
+        floating point numbers.
+    force_ascii : bool, default True
+        Force encoded string to be ASCII.
+    date_unit : str, default 'ms' (milliseconds)
+        The time unit to encode to, governs timestamp and ISO8601
+        precision.  One of 's', 'ms', 'us', 'ns' for second, millisecond,
+        microsecond, and nanosecond respectively.
+    default_handler : callable, default None
+        Handler to call if object cannot otherwise be converted to a
+        suitable format for JSON. Should receive a single argument which is
+        the object to convert and return a serializable object.
+    lines : bool, default False
+        If 'orient' is 'records' write out line-delimited json format. Will
+        throw ValueError if incorrect 'orient' is used.
+    compression : str or dict, default 'infer'
+        For on-the-fly compression of the output data. If str, represents
+        compression mode. If dict, value at 'method' is the compression mode.
+        Compression mode may be any of the following possible
+        values: {'infer', 'gzip', 'bz2', 'zip', 'xz', None}. If compression
+        mode is 'infer' and `path_or_buf` is path-like, then detect
+        compression mode from the following extensions: '.gz', '.bz2',
+        '.zip' or '.xz'. (otherwise no compression). If dict given and
+        mode is one of {'zip', 'xz'}, other entries passed as
+        additional compression options.
+    index : bool, default None
+        Whether to include the index values in the JSON string. Not
+        including the index (``index=False``) is only supported when
+        orient is 'split' or 'table'.
+    indent : int, optional
+       Length of whitespace used to indent each record.
+    partition_cols : list, optional, default None
+        Column names by which to partition the dataset.
+        Columns are partitioned in the order they are given.
+
+    See Also
+    --------
+    read_json : Convert a JSON string to pandas object.
+
+    Notes
+    -----
+    The behavior of ``indent=0`` varies from the stdlib, which does not
+    indent the output but does insert newlines. Currently, ``indent=0``
+    and the default ``indent=None`` are equivalent in pandas, though this
+    may change in a future release.
+
+    ``orient='table'`` contains a 'pandas_version' field under 'schema'.
+    This stores the version of `pandas` used in the latest revision of the
+    schema.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([['a', 'b'], ['c', 'd']],
+    ...                   index=['row 1', 'row 2'],
+    ...                   columns=['col 1', 'col 2'])
+    >>> df.to_json('data.json')
+    >>> # Writing to a file with orient='records'
+    >>> df.to_json('records.json', orient='records')  # doctest: +SKIP
+    >>> # Writing in line-delimited json format
+    >>> df.to_json('ldjson.json', orient='records', lines=True)  # doctest: +SKIP
+    >>> # Write partitioned dataset
+    >>> df.to_json('dataset', partition_cols=['col 1'])  # doctest: +SKIP
+    """
+
+    if kwargs:
+        raise TypeError(
+            f"to_json() got an unexpected keyword argument '{next(iter(kwargs))}'"
+        )
+
+    if path is None:
+        raise NotImplementedError("Currently only support to_json with path specified")
+
+    json_kwargs = dict(
+        date_format=date_format,
+        double_precision=double_precision,
+        force_ascii=force_ascii,
+        date_unit=date_unit,
+        indent=indent,
+    )
+    op = DataFrameToJSON(
+        path=path,
+        orient=orient,
+        default_handler=default_handler,
+        lines=lines,
+        compression=compression,
+        index=index,
+        storage_options=storage_options,
+        partition_cols=partition_cols,
+        json_kwargs=json_kwargs,
+    )
+    return op(df)

maxframe/dataframe/datastore/to_odps.py

@@ -0,0 +1,285 @@
+# 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 itertools
+import logging
+from collections import OrderedDict
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+from odps import ODPS
+from odps.models import Table as ODPSTable
+from odps.types import OdpsSchema, PartitionSpec
+
+from ... import opcodes
+from ...config import options
+from ...core import OutputType
+from ...io.odpsio import build_dataframe_table_meta
+from ...io.odpsio.schema import odps_schema_to_arrow_schema
+from ...lib.dtypes_extension import ArrowDtype
+from ...serialization.serializables import (
+    BoolField,
+    DictField,
+    FieldTypes,
+    Int64Field,
+    ListField,
+    SeriesField,
+    StringField,
+)
+from ...typing_ import TileableType
+from ..core import DataFrame  # noqa: F401
+from ..utils import parse_index
+from .core import DataFrameDataStore
+
+logger = logging.getLogger(__name__)
+
+
+class DataFrameToODPSTable(DataFrameDataStore):
+    _op_type_ = opcodes.TO_ODPS_TABLE
+
+    dtypes = SeriesField("dtypes")
+
+    table_name = StringField("table_name", default=None)
+    partition_spec = StringField("partition_spec", default=None)
+    partition_columns = ListField("partition_columns", FieldTypes.string, default=None)
+    overwrite = BoolField("overwrite", default=None)
+    write_batch_size = Int64Field("write_batch_size", default=None)
+    unknown_as_string = BoolField("unknown_as_string", default=None)
+    index = BoolField("index", default=True)
+    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)
+    use_generated_table_meta = BoolField("use_generated_table_meta", default=False)
+
+    def __init__(self, **kw):
+        super().__init__(_output_types=[OutputType.dataframe], **kw)
+
+    def check_inputs(self, inputs: List[TileableType]):
+        if self.use_generated_table_meta:
+            return None
+        return super().check_inputs(inputs)
+
+    def __call__(self, x):
+        shape = (0,) * len(x.shape)
+        index_value = parse_index(x.index_value.to_pandas()[:0], x.key, "index")
+        columns_value = parse_index(
+            x.columns_value.to_pandas()[:0], x.key, "columns", store_data=True
+        )
+        return self.new_dataframe(
+            [x],
+            shape=shape,
+            dtypes=x.dtypes[:0],
+            index_value=index_value,
+            columns_value=columns_value,
+        )
+
+    @classmethod
+    def get_index_mapping(
+        cls,
+        index_label: Optional[List[str]],
+        raw_index_levels: List[Any],
+    ) -> List[Any]:
+        def_labels = index_label or itertools.repeat(None)
+        def_labels = itertools.chain(def_labels, itertools.repeat(None))
+        names = raw_index_levels
+        if len(names) == 1:
+            default_labels = ["index"]
+        else:
+            default_labels = [f"level_{i}" for i in range(len(names))]
+        indexes = [
+            def_label or name or label
+            for def_label, name, label in zip(def_labels, names, default_labels)
+        ]
+        return [x.lower() for x in indexes]
+
+
+def to_odps_table(
+    df: TileableType,
+    table: Union[ODPSTable, str],
+    partition: Optional[str] = None,
+    partition_col: Union[None, str, List[str]] = None,
+    overwrite: bool = False,
+    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,
+    odps_types: Optional[Dict[str, str]] = None,
+):
+    """
+    Write DataFrame object into a MaxCompute (ODPS) table.
+
+    You need to provide the name of the table to write to. If you want to store
+    data into a specific partitioned of a table, argument `partition` can be used.
+    You can also use `partition_col` to specify DataFrame columns as partition
+    columns, and data in the DataFrame will be grouped by these columns and
+    inserted into partitions the values of these columns.
+
+    If the table does not exist, `to_odps_table` will create one.
+
+    Column names for indexes is determined by `index_label` argument. If the
+    argument is absent, names of the levels is used if they are not None, or
+    default names will be used. The default name for indexes with only one level
+    will be `index`, and for indexes with multiple levels, the name will be
+    `level_x` while x is the index of the level.
+
+    Parameters
+    ----------
+    table: str
+        Name ot the table to write DataFrame into
+    partition: Optional[str]
+        Spec of the partition to write to, can be 'pt1=xxx,pt2=yyy'
+    partition_col: Union[None, str, List[str]]
+        Name of columns in DataFrame as partition columns.
+    overwrite: bool
+        Overwrite data if the table / partition already exists.
+    unknown_as_string: bool
+        If True, object type in the DataFrame will be treated as strings.
+        Otherwise errors might be raised.
+    index: bool
+        If True, indexes will be stored. Otherwise they are ignored.
+    index_label: Union[None, str, List[str]]
+        Specify column names for index levels. If absent, level names or default
+        names will be used.
+    lifecycle: Optional[int]
+        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
+    -------
+    result: DataFrame
+        Stub DataFrame for execution.
+
+    Notes
+    -----
+    `to_odps_table` returns a stub object for execution. The result returned is
+    not reusable.
+
+    Examples
+    --------
+
+    """
+    odps_entry = ODPS.from_global() or ODPS.from_environments()
+    is_schema_enabled = (
+        options.session.enable_schema or odps_entry.is_schema_namespace_enabled()
+    )
+    if isinstance(table, ODPSTable):
+        table = table.full_table_name
+    elif is_schema_enabled and "." not in table:
+        default_schema = (
+            options.session.default_schema or odps_entry.schema or "default"
+        )
+        table = default_schema + "." + table
+
+    if isinstance(index_label, str):
+        index_label = [index_label]
+    if isinstance(partition_col, str):
+        partition_col = [partition_col]
+
+    if index_label and len(index_label) != len(df.index.names):
+        raise ValueError(
+            f"index_label needs {len(df.index.nlevels)} labels "
+            f"but it only have {len(index_label)}"
+        )
+
+    # check if table partition columns conflicts with dataframe columns
+    table_cols = set(build_dataframe_table_meta(df).table_column_names)
+    partition_col_set = (
+        set(x.lower() for x in PartitionSpec(partition).keys()) if partition else set()
+    )
+    if partition:
+        partition_intersect = partition_col_set & table_cols
+        if partition_intersect:
+            raise ValueError(
+                f"Data column(s) {partition_intersect} in the dataframe"
+                " cannot be used in parameter 'partition'."
+                " Use 'partition_col' instead."
+            )
+
+    if index:
+        index_cols = set(
+            DataFrameToODPSTable.get_index_mapping(index_label, df.index.names)
+        )
+        index_table_intersect = index_cols & table_cols
+        if index_table_intersect:
+            raise ValueError(
+                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 "
+                f"with partition column(s)."
+            )
+
+    if partition_col:
+        partition_diff = set(x.lower() for x in partition_col) - table_cols
+        if partition_diff:
+            raise ValueError(
+                f"Partition column(s) {partition_diff}"
+                " 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]
+
+    if odps_types is None:
+        target_dtypes = df.dtypes
+    else:
+        odps_schema = OdpsSchema.from_dict(odps_types)
+        arrow_schema = odps_schema_to_arrow_schema(odps_schema)
+        pd_col_to_dtype = {
+            nm: ArrowDtype(tp) for nm, tp in zip(arrow_schema.names, arrow_schema.types)
+        }
+        target_dtypes_dict = OrderedDict(
+            [(col, pd_col_to_dtype.get(col, dt)) for col, dt in df.dtypes.items()]
+        )
+        target_dtypes = pd.Series(target_dtypes_dict)
+
+    op = DataFrameToODPSTable(
+        dtypes=target_dtypes,
+        table_name=table,
+        unknown_as_string=unknown_as_string,
+        partition_spec=partition,
+        partition_columns=partition_col,
+        overwrite=overwrite,
+        index=index,
+        index_label=index_label,
+        lifecycle=lifecycle or options.session.table_lifecycle,
+        table_properties=table_properties or None,
+        primary_key=primary_key or None,
+    )
+    return op(df)

maxframe/dataframe/datastore/to_parquet.py

@@ -0,0 +1,121 @@
+# 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.
+
+from ... import opcodes
+from ...serialization.serializables import BoolField, DictField, StringField
+from ..datasource.read_parquet import check_engine
+from ..utils import parse_index
+from .core import LakeDataStore
+
+
+class DataFrameToParquet(LakeDataStore):
+    _op_type_ = opcodes.TO_PARQUET
+
+    engine = StringField("engine")
+    index = BoolField("index")
+    additional_kwargs = DictField("additional_kwargs")
+
+    @classmethod
+    def _get_path(cls, path, i):
+        if "*" not in path:
+            return path
+        return path.replace("*", str(i))
+
+    def __call__(self, df):
+        index_value = parse_index(df.index_value.to_pandas()[:0], df)
+        columns_value = parse_index(df.columns_value.to_pandas()[:0], store_data=True)
+        return self.new_dataframe(
+            [df],
+            shape=(0, 0),
+            dtypes=df.dtypes[:0],
+            index_value=index_value,
+            columns_value=columns_value,
+        )
+
+
+def to_parquet(
+    df,
+    path,
+    engine="auto",
+    compression="snappy",
+    index=None,
+    partition_cols=None,
+    storage_options: dict = None,
+    **kwargs,
+):
+    """
+    Write a DataFrame to the binary parquet format, each chunk will be
+    written to a Parquet file.
+
+    Parameters
+    ----------
+    path : str or file-like object
+        If path is a string with wildcard e.g. '/to/path/out-*.parquet',
+        `to_parquet` will try to write multiple files, for instance,
+        chunk (0, 0) will write data into '/to/path/out-0.parquet'.
+        If path is a string without wildcard, we will treat it as a directory.
+
+    engine : {'auto', 'pyarrow', 'fastparquet'}, default 'auto'
+        Parquet library to use. The default behavior is to try 'pyarrow',
+        falling back to 'fastparquet' if 'pyarrow' is unavailable.
+
+    compression : {'snappy', 'gzip', 'brotli', None}, default 'snappy'
+        Name of the compression to use. Use ``None`` for no compression.
+
+    index : bool, default None
+        If ``True``, include the dataframe's index(es) in the file output.
+        If ``False``, they will not be written to the file.
+        If ``None``, similar to ``True`` the dataframe's index(es)
+        will be saved. However, instead of being saved as values,
+        the RangeIndex will be stored as a range in the metadata so it
+        doesn't require much space and is faster. Other indexes will
+        be included as columns in the file output.
+
+    partition_cols : list, optional, default None
+        Column names by which to partition the dataset.
+        Columns are partitioned in the order they are given.
+        Must be None if path is not a string.
+
+    **kwargs
+        Additional arguments passed to the parquet library.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame(data={'col1': [1, 2], 'col2': [3, 4]})
+    >>> df.to_parquet('*.parquet.gzip',
+    ...               compression='gzip').execute()  # doctest: +SKIP
+    >>> md.read_parquet('*.parquet.gzip').execute()  # doctest: +SKIP
+       col1  col2
+    0     1     3
+    1     2     4
+
+    >>> import io
+    >>> f = io.BytesIO()
+    >>> df.to_parquet(f).execute()
+    >>> f.seek(0)
+    0
+    >>> content = f.read()
+    """
+    engine = check_engine(engine)
+    op = DataFrameToParquet(
+        path=path,
+        engine=engine,
+        compression=compression,
+        index=index,
+        partition_cols=partition_cols,
+        storage_options=storage_options,
+        additional_kwargs=kwargs,
+    )
+    return op(df)

maxframe/dataframe/extensions/__init__.py

@@ -0,0 +1,70 @@
+# 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.
+
+from ...core import CachedAccessor
+from .accessor import (
+    DataFrameMaxFrameAccessor,
+    IndexMaxFrameAccessor,
+    SeriesMaxFrameAccessor,
+)
+from .apply_chunk import (
+    DataFrameApplyChunk,
+    DataFrameApplyChunkOperator,
+    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("apply_chunk", df_apply_chunk)
+    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:
+            t.mf = CachedAccessor("mf", DataFrameMaxFrameAccessor)
+    if SeriesMaxFrameAccessor._api_count:
+        for t in SERIES_TYPE:
+            t.mf = CachedAccessor("mf", SeriesMaxFrameAccessor)
+    if IndexMaxFrameAccessor._api_count:
+        for t in INDEX_TYPE:
+            t.mf = CachedAccessor("mf", IndexMaxFrameAccessor)
+
+
+_install()
+del _install