maxframe 2.2.0__cp312-cp312-win_amd64.whl

maxframe/dataframe/datastore/core.py

@@ -0,0 +1,19 @@
+# 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 ..operators import DataFrameOperator, DataFrameOperatorMixin
+
+
+class DataFrameDataStore(DataFrameOperator, DataFrameOperatorMixin):
+    pass

maxframe/dataframe/datastore/tests/__init__.py

@@ -0,0 +1,13 @@
+# 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.

maxframe/dataframe/datastore/tests/test_to_odps.py

@@ -0,0 +1,99 @@
+# 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 pandas as pd
+import pytest
+
+from ... import DataFrame, Index
+from ..to_odps import to_odps_table
+
+
+@pytest.fixture
+def df():
+    return DataFrame({"A": [1, 2], "B": [3, 4]})
+
+
+@pytest.fixture
+def df_with_named_index():
+    return DataFrame({"A": [1, 2], "B": [3, 4]}, index=Index([1, 2], name="A"))
+
+
+@pytest.fixture
+def df_with_named_multi_indexes():
+    arrays = [
+        ["c1", "c2"],
+        ["d1", "d2"],
+        ["e1", "e2"],
+    ]
+    multi_index = pd.MultiIndex.from_arrays(arrays, names=("C", "D", "E"))
+    return DataFrame(
+        {"A": [1, 2], "B": [3, 4]},
+        index=multi_index,
+    )
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"partition_col": ["A", "C"]},
+        {"partition_col": "C"},
+        {"partition": "a=1,C=2"},
+    ],
+)
+def test_to_odps_table_validation(df, kwargs):
+    with pytest.raises(ValueError):
+        to_odps_table(df, "test_table", **kwargs)
+
+
+@pytest.mark.parametrize(
+    "kwargs",
+    [
+        {"partition_col": ["a", "B"]},
+        {"partition_col": "a"},
+        {"partition": "C=1,d=2"},
+    ],
+)
+def test_to_odps_table_vaild(df, kwargs):
+    to_odps_table(df, "test_table", **kwargs)
+
+
+def test_to_odps_table_column_conflicts(
+    df, df_with_named_index, df_with_named_multi_indexes
+):
+    to_odps_table(df.reset_index(), "test_table", index=False)
+    to_odps_table(df.reset_index(), "test_table", index_label="C")
+    with pytest.raises(ValueError):
+        to_odps_table(df.reset_index(), "test_table")
+
+    to_odps_table(df_with_named_index, "test_table", index=False)
+    to_odps_table(df_with_named_index, "test_table", index_label="C")
+    with pytest.raises(ValueError):
+        to_odps_table(df_with_named_index, "test_table")
+
+    to_odps_table(df, "test_table", partition="C='1'")
+    with pytest.raises(ValueError):
+        to_odps_table(df, "test_table", partition="A='1'")
+
+    with pytest.raises(ValueError):
+        to_odps_table(df, "test_table", partition="A='1'")
+
+    to_odps_table(df_with_named_multi_indexes, "test_table")
+    to_odps_table(
+        df_with_named_multi_indexes, "test_table", partition="C='1'", index=False
+    )
+    with pytest.raises(ValueError):
+        to_odps_table(df_with_named_multi_indexes, "test_table", partition="C='1'")
+
+    df_with_named_multi_indexes.index.names = ["C1", "D1", "E1"]
+    to_odps_table(df_with_named_multi_indexes, "test_table", partition="C='1'")

maxframe/dataframe/datastore/to_csv.py

@@ -0,0 +1,219 @@
+# 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 (
+    AnyField,
+    BoolField,
+    DictField,
+    Int32Field,
+    Int64Field,
+    ListField,
+    StringField,
+)
+from ..utils import parse_index
+from .core import DataFrameDataStore
+
+
+class DataFrameToCSV(DataFrameDataStore):
+    _op_type_ = opcodes.TO_CSV
+
+    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)
+
+    @property
+    def one_file(self):
+        # if wildcard in path, write csv into multiple files
+        return "*" not in self.path
+
+    def __call__(self, df):
+        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_csv(
+    df,
+    path,
+    sep=",",
+    na_rep="",
+    float_format=None,
+    columns=None,
+    header=True,
+    index=True,
+    index_label=None,
+    mode="w",
+    encoding=None,
+    compression="infer",
+    quoting=None,
+    quotechar='"',
+    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.
+
+    Parameters
+    ----------
+    path : str
+        File path.
+        If path is a string with wildcard e.g. '/to/path/out-*.csv',
+        to_csv will try to write multiple files, for instance,
+        chunk (0, 0) will write data into '/to/path/out-0.csv'.
+        If path is a string without wildcard,
+        all data will be written into a single file.
+    sep : str, default ','
+        String of length 1. Field delimiter for the output file.
+    na_rep : str, default ''
+        Missing data representation.
+    float_format : str, default None
+        Format string for floating point numbers.
+    columns : sequence, optional
+        Columns to write.
+    header : bool or list of str, default True
+        Write out the column names. If a list of strings is given it is
+        assumed to be aliases for the column names.
+    index : bool, default True
+        Write row names (index).
+    index_label : str or sequence, or False, default None
+        Column label for index column(s) if desired. If None is given, and
+        `header` and `index` are True, then the index names are used. A
+        sequence should be given if the object uses MultiIndex. If
+        False do not print fields for index names. Use index_label=False
+        for easier importing in R.
+    mode : str
+        Python write mode, default 'w'.
+    encoding : str, optional
+        A string representing the encoding to use in the output file,
+        defaults to 'utf-8'.
+    compression : str or dict, default 'infer'
+        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 'zip' or inferred as 'zip', other entries passed as
+        additional compression options.
+    quoting : optional constant from csv module
+        Defaults to csv.QUOTE_MINIMAL. If you have set a `float_format`
+        then floats are converted to strings and thus csv.QUOTE_NONNUMERIC
+        will treat them as non-numeric.
+    quotechar : str, default '\"'
+        String of length 1. Character used to quote fields.
+    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.).
+    chunksize : int or None
+        Rows to write at a time.
+    date_format : str, default None
+        Format string for datetime objects.
+    doublequote : bool, default True
+        Control quoting of `quotechar` inside a field.
+    escapechar : str, default None
+        String of length 1. Character used to escape `sep` and `quotechar`
+        when appropriate.
+    decimal : str, default '.'
+        Character recognized as decimal separator. E.g. use ',' for
+        European data.
+    Returns
+    -------
+    None or str
+        If path_or_buf is None, returns the resulting csv format as a
+        string. Otherwise returns None.
+
+    See Also
+    --------
+    read_csv : Load a CSV file into a DataFrame.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'name': ['Raphael', 'Donatello'],
+    ...                    'mask': ['red', 'purple'],
+    ...                    '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")
+    op = DataFrameToCSV(
+        path=path,
+        sep=sep,
+        na_rep=na_rep,
+        float_format=float_format,
+        columns=columns,
+        header=header,
+        index=index,
+        index_label=index_label,
+        mode=mode,
+        encoding=encoding,
+        compression=compression,
+        quoting=quoting,
+        quotechar=quotechar,
+        line_terminator=lineterminator,
+        chunksize=chunksize,
+        date_format=date_format,
+        doublequote=doublequote,
+        escapechar=escapechar,
+        decimal=decimal,
+        storage_options=storage_options,
+    )
+    return op(df)

maxframe/dataframe/datastore/to_odps.py

@@ -0,0 +1,258 @@
+# 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 typing import Any, List, Optional, Union
+
+from odps import ODPS
+from odps.models import Table as ODPSTable
+from odps.types import PartitionSpec
+
+from ... import opcodes
+from ...config import options
+from ...core import OutputType
+from ...io.odpsio import build_dataframe_table_meta
+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)
+
+    def __init__(self, **kw):
+        super().__init__(_output_types=[OutputType.dataframe], **kw)
+
+    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,
+):
+    """
+    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()
+    if isinstance(table, ODPSTable):
+        table = table.full_table_name
+    elif options.session.enable_schema 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]
+
+    op = DataFrameToODPSTable(
+        dtypes=df.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/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