maxframe 0.1.0b5__cp39-cp39-macosx_11_0_arm64.whl

maxframe/dataframe/indexing/set_axis.py

@@ -0,0 +1,194 @@
+# Copyright 1999-2024 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 numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, get_output_types
+from ...serialization.serializables import AnyField, Int8Field, KeyField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+
+class DataFrameSetAxis(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DATAFRAME_SET_AXIS
+
+    input = KeyField("input", default=None)
+    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]
+
+    def __call__(self, df_or_series):
+        new_size = self.value.shape[0]
+        expect_size = df_or_series.axes[self.axis].shape[0]
+        if (
+            not np.isnan(new_size)
+            and not np.isnan(expect_size)
+            and new_size != expect_size
+        ):
+            raise ValueError(
+                f"Length mismatch: Expected axis has {expect_size} elements, "
+                f"new values have {new_size} elements"
+            )
+
+        params = df_or_series.params
+        if self.axis == 0:
+            params["index_value"] = (
+                parse_index(self.value)
+                if isinstance(self.value, pd.Index)
+                else self.value.index_value
+            )
+        else:
+            params["columns_value"] = (
+                parse_index(self.value, store_data=True)
+                if isinstance(self.value, pd.Index)
+                else self.value.index_value
+            )
+            pd_columns = (
+                self.value.index_value.to_pandas()
+                if isinstance(self.value, ENTITY_TYPE)
+                else self.value
+            )
+            params["dtypes"] = params["dtypes"].set_axis(pd_columns)
+
+        self._output_types = get_output_types(df_or_series)
+        inputs = [df_or_series]
+        if isinstance(self.value, ENTITY_TYPE):
+            inputs += [self.value]
+        return self.new_tileable(inputs, **params)
+
+
+def _set_axis(df_or_axis, labels, axis=0, inplace=False):
+    axis = validate_axis(axis, df_or_axis)
+    if not isinstance(labels, ENTITY_TYPE) and not isinstance(labels, pd.Index):
+        labels = pd.Index(labels)
+
+    op = DataFrameSetAxis(value=labels, axis=axis)
+    result = op(df_or_axis)
+    if inplace:
+        df_or_axis.data = result.data
+    else:
+        return result
+
+
+def df_set_axis(df, labels, axis=0, inplace=False):
+    """
+    Assign desired index to given axis.
+
+    Indexes for column or row labels can be changed by assigning
+    a list-like or Index.
+
+    Parameters
+    ----------
+    labels : list-like, Index
+        The values for the new index.
+
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        The axis to update. The value 0 identifies the rows, and 1 identifies the columns.
+
+    inplace : bool, default False
+        Whether to return a new DataFrame instance.
+
+    Returns
+    -------
+    renamed : DataFrame or None
+        An object of type DataFrame or None if ``inplace=True``.
+
+    See Also
+    --------
+    DataFrame.rename_axis : Alter the name of the index or columns.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]})
+
+    Change the row labels.
+
+    >>> df.set_axis(['a', 'b', 'c'], axis='index').execute()
+       A  B
+    a  1  4
+    b  2  5
+    c  3  6
+
+    Change the column labels.
+
+    >>> df.set_axis(['I', 'II'], axis='columns').execute()
+       I  II
+    0  1   4
+    1  2   5
+    2  3   6
+
+    Now, update the labels inplace.
+
+    >>> df.set_axis(['i', 'ii'], axis='columns', inplace=True)
+    >>> df.execute()
+       i  ii
+    0  1   4
+    1  2   5
+    2  3   6
+    """
+    return _set_axis(df, labels, axis=axis, inplace=inplace)
+
+
+def series_set_axis(series, labels, axis=0, inplace=False):
+    """
+    Assign desired index to given axis.
+
+    Indexes for row labels can be changed by assigning
+    a list-like or Index.
+
+    Parameters
+    ----------
+    labels : list-like, Index
+        The values for the new index.
+
+    axis : {0 or 'index'}, default 0
+        The axis to update. The value 0 identifies the rows.
+
+    inplace : bool, default False
+        Whether to return a new Series instance.
+
+    Returns
+    -------
+    renamed : Series or None
+        An object of type Series or None if ``inplace=True``.
+
+    See Also
+    --------
+    Series.rename_axis : Alter the name of the index.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series([1, 2, 3])
+    >>> s.execute()
+    0    1
+    1    2
+    2    3
+    dtype: int64
+
+    >>> s.set_axis(['a', 'b', 'c'], axis=0).execute()
+    a    1
+    b    2
+    c    3
+    dtype: int64
+    """
+    return _set_axis(series, labels, axis=axis, inplace=inplace)

maxframe/dataframe/indexing/set_index.py

@@ -0,0 +1,61 @@
+# Copyright 1999-2024 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 ...core import OutputType
+from ...serialization.serializables import AnyField, BoolField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_empty_df, parse_index
+
+
+class DataFrameSetIndex(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DATAFRAME_SET_INDEX
+
+    keys = AnyField("keys")
+    drop = BoolField("drop", default=True)
+    append = BoolField("append", default=False)
+    verify_integrity = BoolField("verify_integrity", default=False)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def __call__(self, df):
+        new_df = build_empty_df(df.dtypes).set_index(
+            keys=self.keys,
+            drop=self.drop,
+            append=self.append,
+            verify_integrity=self.verify_integrity,
+        )
+        return self.new_dataframe(
+            [df],
+            shape=(df.shape[0], new_df.shape[1]),
+            dtypes=new_df.dtypes,
+            index_value=parse_index(new_df.index),
+            columns_value=parse_index(new_df.columns, store_data=True),
+        )
+
+
+def set_index(df, keys, drop=True, append=False, inplace=False, verify_integrity=False):
+    op = DataFrameSetIndex(
+        keys=keys,
+        drop=drop,
+        append=append,
+        verify_integrity=verify_integrity,
+        output_types=[OutputType.dataframe],
+    )
+    result = op(df)
+    if not inplace:
+        return result
+    else:
+        df.data = result.data

maxframe/dataframe/indexing/setitem.py

@@ -0,0 +1,130 @@
+# Copyright 1999-2024 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 numpy as np
+import pandas as pd
+from pandas.api.types import is_list_like
+
+from ... import opcodes
+from ...core import OutputType
+from ...serialization.serializables import AnyField, KeyField
+from ...tensor.core import TENSOR_TYPE
+from ...utils import pd_release_version
+from ..core import DATAFRAME_TYPE, SERIES_TYPE, DataFrame
+from ..initializer import DataFrame as asframe
+from ..initializer import Series as asseries
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+# in pandas 1.0.x, __setitem__ with a list with missing items are not allowed
+_allow_set_missing_list = pd_release_version[:2] >= (1, 1)
+
+
+class DataFrameSetitem(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.INDEXSETVALUE
+
+    target = KeyField("target")
+    indexes = AnyField("indexes", default=None)
+    value = AnyField("value", default=None)
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+        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]
+        if len(inputs) > 1:
+            self.value = self._inputs[-1]
+
+    @staticmethod
+    def _is_scalar_tensor(t):
+        return isinstance(t, TENSOR_TYPE) and t.ndim == 0
+
+    def __call__(self, target: DataFrame, value):
+        raw_target = target
+
+        inputs = [target]
+        if np.isscalar(value):
+            value_dtype = np.array(value).dtype
+        elif self._is_scalar_tensor(value):
+            inputs.append(value)
+            value_dtype = value.dtype
+        else:
+            if isinstance(value, (pd.Series, SERIES_TYPE)):
+                value = asseries(value)
+                value_dtype = value.dtype
+            elif isinstance(value, (pd.DataFrame, DATAFRAME_TYPE)):
+                if len(self.indexes) != value.shape[1]:  # pragma: no cover
+                    raise ValueError("Columns must be same length as key")
+
+                value = asframe(value)
+                value_dtype = pd.Series(list(value.dtypes), index=self.indexes)
+            elif is_list_like(value) or isinstance(value, TENSOR_TYPE):
+                # convert to numpy to get actual dim and shape
+                if is_list_like(value):
+                    value = np.array(value)
+
+                if value.ndim == 1:
+                    value = asseries(value, index=target.index)
+                    value_dtype = value.dtype
+                else:
+                    if len(self.indexes) != value.shape[1]:  # pragma: no cover
+                        raise ValueError("Columns must be same length as key")
+
+                    value = asframe(value, index=target.index)
+                    value_dtype = pd.Series(list(value.dtypes), index=self.indexes)
+            else:  # pragma: no cover
+                raise TypeError(
+                    "Wrong value type, could be one of scalar, Series or tensor"
+                )
+
+            if target.shape[0] == 0:
+                # target empty, reindex target first
+                target = target.reindex(value.index)
+                inputs[0] = target
+            elif value.index_value.key != target.index_value.key:
+                # need reindex when target df is not empty and index different
+                value = value.reindex(target.index)
+            inputs.append(value)
+
+        index_value = target.index_value
+        dtypes = target.dtypes.copy(deep=True)
+
+        try:
+            dtypes.loc[self.indexes] = value_dtype
+        except KeyError:
+            # when some index not exist, try update one by one
+            if isinstance(value_dtype, pd.Series):
+                for idx in self.indexes:
+                    dtypes.loc[idx] = value_dtype.loc[idx]
+            else:
+                for idx in self.indexes:
+                    dtypes.loc[idx] = value_dtype
+
+        columns_value = parse_index(dtypes.index, store_data=True)
+        ret = self.new_dataframe(
+            inputs,
+            shape=(target.shape[0], len(dtypes)),
+            dtypes=dtypes,
+            index_value=index_value,
+            columns_value=columns_value,
+        )
+        raw_target.data = ret.data
+
+
+def dataframe_setitem(df, col, value):
+    op = DataFrameSetitem(target=df, indexes=col, value=value)
+    return op(df, value)

maxframe/dataframe/indexing/tests/__init__.py

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