maxframe 0.1.0b5__cp311-cp311-macosx_11_0_arm64.whl

maxframe/dataframe/missing/dropna.py

@@ -0,0 +1,280 @@
+# 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
+
+from ... import opcodes
+from ...core import OutputType
+from ...serialization.serializables import AnyField, BoolField, Int32Field, StringField
+from ...utils import no_default, pd_release_version
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index, validate_axis
+
+_drop_na_enable_no_default = pd_release_version[:2] >= (1, 5)
+
+
+class DataFrameDropNA(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DROP_NA
+
+    axis = AnyField("axis", default=None)
+    how = StringField("how", default=None)
+    thresh = Int32Field("thresh", default=None)
+    subset = AnyField("subset", default=None)
+
+    # when True, dropna will be called on the input,
+    # otherwise non-nan counts will be used
+    drop_directly = BoolField("drop_directly", default=None)
+    # size of subset, used when how == 'any'
+    subset_size = Int32Field("subset_size", default=None)
+
+    def __init__(self, sparse=None, output_types=None, **kw):
+        super().__init__(_output_types=output_types, sparse=sparse, **kw)
+
+    def __call__(self, df):
+        new_shape = list(df.shape)
+        new_shape[0] = np.nan
+
+        params = df.params.copy()
+        params["index_value"] = parse_index(None, df.key, df.index_value.key)
+        params["shape"] = tuple(new_shape)
+        return self.new_tileable([df], **params)
+
+
+def df_dropna(
+    df, axis=0, how=no_default, thresh=no_default, subset=None, inplace=False
+):
+    """
+    Remove missing values.
+
+    See the :ref:`User Guide <missing_data>` for more on which values are
+    considered missing, and how to work with missing data.
+
+    Parameters
+    ----------
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        Determine if rows or columns which contain missing values are
+        removed.
+
+        * 0, or 'index' : Drop rows which contain missing values.
+        * 1, or 'columns' : Drop columns which contain missing value.
+
+        .. versionchanged:: 1.0.0
+
+           Pass tuple or list to drop on multiple axes.
+           Only a single axis is allowed.
+
+    how : {'any', 'all'}, default 'any'
+        Determine if row or column is removed from DataFrame, when we have
+        at least one NA or all NA.
+
+        * 'any' : If any NA values are present, drop that row or column.
+        * 'all' : If all values are NA, drop that row or column.
+
+    thresh : int, optional
+        Require that many non-NA values.
+    subset : array-like, optional
+        Labels along other axis to consider, e.g. if you are dropping rows
+        these would be a list of columns to include.
+    inplace : bool, default False
+        If True, do operation inplace and return None.
+
+    Returns
+    -------
+    DataFrame
+        DataFrame with NA entries dropped from it.
+
+    See Also
+    --------
+    DataFrame.isna: Indicate missing values.
+    DataFrame.notna : Indicate existing (non-missing) values.
+    DataFrame.fillna : Replace missing values.
+    Series.dropna : Drop missing values.
+    Index.dropna : Drop missing indices.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({"name": ['Alfred', 'Batman', 'Catwoman'],
+    ...                    "toy": [np.nan, 'Batmobile', 'Bullwhip'],
+    ...                    "born": [md.NaT, md.Timestamp("1940-04-25"),
+    ...                             md.NaT]})
+    >>> df.execute()
+           name        toy       born
+    0    Alfred        NaN        NaT
+    1    Batman  Batmobile 1940-04-25
+    2  Catwoman   Bullwhip        NaT
+
+    Drop the rows where at least one element is missing.
+
+    >>> df.dropna().execute()
+         name        toy       born
+    1  Batman  Batmobile 1940-04-25
+
+    Drop the rows where all elements are missing.
+
+    >>> df.dropna(how='all').execute()
+           name        toy       born
+    0    Alfred        NaN        NaT
+    1    Batman  Batmobile 1940-04-25
+    2  Catwoman   Bullwhip        NaT
+
+    Keep only the rows with at least 2 non-NA values.
+
+    >>> df.dropna(thresh=2).execute()
+           name        toy       born
+    1    Batman  Batmobile 1940-04-25
+    2  Catwoman   Bullwhip        NaT
+
+    Define in which columns to look for missing values.
+
+    >>> df.dropna(subset=['name', 'born']).execute()
+           name        toy       born
+    1    Batman  Batmobile 1940-04-25
+
+    Keep the DataFrame with valid entries in the same variable.
+
+    >>> df.dropna(inplace=True)
+    >>> df.execute()
+         name        toy       born
+    1  Batman  Batmobile 1940-04-25
+    """
+    axis = validate_axis(axis, df)
+    if axis != 0:
+        raise NotImplementedError("Does not support dropna on DataFrame when axis=1")
+    if (
+        _drop_na_enable_no_default
+        and (how is not no_default)
+        and (thresh is not no_default)
+    ):
+        raise TypeError(
+            "You cannot set both the how and thresh arguments at the same time."
+        )
+    if thresh is no_default and how is no_default:
+        how = "any"
+
+    op = DataFrameDropNA(
+        axis=axis,
+        how=how,
+        thresh=thresh,
+        subset=subset,
+        output_types=[OutputType.dataframe],
+    )
+    out_df = op(df)
+    if inplace:
+        df.data = out_df.data
+    else:
+        return out_df
+
+
+def series_dropna(series, axis=0, inplace=False, how=None):
+    """
+    Return a new Series with missing values removed.
+
+    See the :ref:`User Guide <missing_data>` for more on which values are
+    considered missing, and how to work with missing data.
+
+    Parameters
+    ----------
+    axis : {0 or 'index'}, default 0
+        There is only one axis to drop values from.
+    inplace : bool, default False
+        If True, do operation inplace and return None.
+    how : str, optional
+        Not in use. Kept for compatibility.
+
+    Returns
+    -------
+    Series
+        Series with NA entries dropped from it.
+
+    See Also
+    --------
+    Series.isna: Indicate missing values.
+    Series.notna : Indicate existing (non-missing) values.
+    Series.fillna : Replace missing values.
+    DataFrame.dropna : Drop rows or columns which contain NA values.
+    Index.dropna : Drop missing indices.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> ser = md.Series([1., 2., np.nan])
+    >>> ser.execute()
+    0    1.0
+    1    2.0
+    2    NaN
+    dtype: float64
+
+    Drop NA values from a Series.
+
+    >>> ser.dropna().execute()
+    0    1.0
+    1    2.0
+    dtype: float64
+
+    Keep the Series with valid entries in the same variable.
+
+    >>> ser.dropna(inplace=True)
+    >>> ser.execute()
+    0    1.0
+    1    2.0
+    dtype: float64
+
+    Empty strings are not considered NA values. ``None`` is considered an
+    NA value.
+
+    >>> ser = md.Series([np.NaN, 2, md.NaT, '', None, 'I stay'])
+    >>> ser.execute()
+    0       NaN
+    1         2
+    2       NaT
+    3
+    4      None
+    5    I stay
+    dtype: object
+    >>> ser.dropna().execute()
+    1         2
+    3
+    5    I stay
+    dtype: object
+    """
+    axis = validate_axis(axis, series)
+    op = DataFrameDropNA(
+        axis=axis,
+        how=how,
+        output_types=[OutputType.series],
+    )
+    out_series = op(series)
+    if inplace:
+        series.data = out_series.data
+    else:
+        return out_series
+
+
+def index_dropna(index, how="any"):
+    """
+    Return Index without NA/NaN values.
+
+    Parameters
+    ----------
+    how : {'any', 'all'}, default 'any'
+        If the Index is a MultiIndex, drop the value when any or all levels
+        are NaN.
+
+    Returns
+    -------
+    Index
+    """
+    op = DataFrameDropNA(axis=0, how=how, output_types=[OutputType.index])
+    return op(index)

maxframe/dataframe/missing/fillna.py

@@ -0,0 +1,275 @@
+# 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 pandas as pd
+
+from ... import opcodes
+from ...core import ENTITY_TYPE, Entity, get_output_types
+from ...serialization.serializables import AnyField, Int64Field, StringField
+from ..core import DATAFRAME_TYPE, SERIES_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import validate_axis
+
+
+class FillNA(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.FILL_NA
+
+    value = AnyField(
+        "value", on_serialize=lambda x: x.data if isinstance(x, Entity) else x
+    )
+    method = StringField("method", default=None)
+    axis = AnyField("axis", default=0)
+    limit = Int64Field("limit", default=None)
+    downcast = AnyField("downcast", default=None)
+
+    def __init__(self, output_limit=1, **kw):
+        super().__init__(output_limit=output_limit, **kw)
+
+    def _set_inputs(self, inputs):
+        super()._set_inputs(inputs)
+        if self.method is None and len(inputs) > 1:
+            self.value = self._inputs[1]
+
+    def __call__(self, a, value_df=None):
+        method = getattr(self, "method", None)
+        if method == "backfill":
+            method = "bfill"
+        elif method == "pad":
+            method = "ffill"
+        self.method = method
+        axis = getattr(self, "axis", None) or 0
+        self.axis = validate_axis(axis, a)
+
+        inputs = [a]
+        if value_df is not None:
+            inputs.append(value_df)
+        if isinstance(a, DATAFRAME_TYPE):
+            return self.new_dataframe(
+                inputs,
+                shape=a.shape,
+                dtypes=a.dtypes,
+                index_value=a.index_value,
+                columns_value=a.columns_value,
+            )
+        elif isinstance(a, SERIES_TYPE):
+            return self.new_series(
+                inputs,
+                shape=a.shape,
+                dtype=a.dtype,
+                index_value=a.index_value,
+                name=a.name,
+            )
+        else:
+            return self.new_index(
+                inputs,
+                shape=a.shape,
+                dtype=a.dtype,
+                index_value=a.index_value,
+                name=a.name,
+                names=a.names,
+            )
+
+
+def fillna(
+    df, value=None, method=None, axis=None, inplace=False, limit=None, downcast=None
+):
+    """
+    Fill NA/NaN values using the specified method.
+
+    Parameters
+    ----------
+    value : scalar, dict, Series, or DataFrame
+        Value to use to fill holes (e.g. 0), alternately a
+        dict/Series/DataFrame of values specifying which value to use for
+        each index (for a Series) or column (for a DataFrame).  Values not
+        in the dict/Series/DataFrame will not be filled. This value cannot
+        be a list.
+    method : {'backfill', 'bfill', 'pad', 'ffill', None}, default None
+        Method to use for filling holes in reindexed Series
+        pad / ffill: propagate last valid observation forward to next valid
+        backfill / bfill: use next valid observation to fill gap.
+    axis : {0 or 'index', 1 or 'columns'}
+        Axis along which to fill missing values.
+    inplace : bool, default False
+        If True, fill in-place. Note: this will modify any
+        other views on this object (e.g., a no-copy slice for a column in a
+        DataFrame).
+    limit : int, default None
+        If method is specified, this is the maximum number of consecutive
+        NaN values to forward/backward fill. In other words, if there is
+        a gap with more than this number of consecutive NaNs, it will only
+        be partially filled. If method is not specified, this is the
+        maximum number of entries along the entire axis where NaNs will be
+        filled. Must be greater than 0 if not None.
+    downcast : dict, default is None
+        A dict of item->dtype of what to downcast if possible,
+        or the string 'infer' which will try to downcast to an appropriate
+        equal type (e.g. float64 to int64 if possible).
+
+    Returns
+    -------
+    DataFrame or None
+        Object with missing values filled or None if ``inplace=True``.
+
+    See Also
+    --------
+    interpolate : Fill NaN values using interpolation.
+    reindex : Conform object to new index.
+    asfreq : Convert TimeSeries to specified frequency.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([[mt.nan, 2, mt.nan, 0],
+    ...                    [3, 4, mt.nan, 1],
+    ...                    [mt.nan, mt.nan, mt.nan, 5],
+    ...                    [mt.nan, 3, mt.nan, 4]],
+    ...                   columns=list('ABCD'))
+    >>> df.execute()
+         A    B   C  D
+    0  NaN  2.0 NaN  0
+    1  3.0  4.0 NaN  1
+    2  NaN  NaN NaN  5
+    3  NaN  3.0 NaN  4
+
+    Replace all NaN elements with 0s.
+
+    >>> df.fillna(0).execute()
+        A   B   C   D
+    0   0.0 2.0 0.0 0
+    1   3.0 4.0 0.0 1
+    2   0.0 0.0 0.0 5
+    3   0.0 3.0 0.0 4
+
+    We can also propagate non-null values forward or backward.
+
+    >>> df.fillna(method='ffill').execute()
+        A   B   C   D
+    0   NaN 2.0 NaN 0
+    1   3.0 4.0 NaN 1
+    2   3.0 4.0 NaN 5
+    3   3.0 3.0 NaN 4
+
+    Replace all NaN elements in column 'A', 'B', 'C', and 'D', with 0, 1,
+    2, and 3 respectively.
+
+    >>> values = {'A': 0, 'B': 1, 'C': 2, 'D': 3}
+    >>> df.fillna(value=values).execute()
+        A   B   C   D
+    0   0.0 2.0 2.0 0
+    1   3.0 4.0 2.0 1
+    2   0.0 1.0 2.0 5
+    3   0.0 3.0 2.0 4
+    """
+    if value is None and method is None:
+        raise ValueError("Must specify a fill 'value' or 'method'.")
+    elif value is not None and method is not None:
+        raise ValueError("Cannot specify both 'value' and 'method'.")
+
+    if isinstance(df, SERIES_TYPE) and isinstance(
+        value, (DATAFRAME_TYPE, pd.DataFrame)
+    ):
+        raise ValueError(
+            '"value" parameter must be a scalar, dict or Series, but you passed a "%s"'
+            % type(value).__name__
+        )
+
+    if downcast is not None:
+        raise NotImplementedError(
+            'Currently argument "downcast" is not implemented yet'
+        )
+    if limit is not None:
+        raise NotImplementedError('Currently argument "limit" is not implemented yet')
+
+    if isinstance(value, ENTITY_TYPE):
+        value, value_df = None, value
+    else:
+        value_df = None
+
+    op = FillNA(
+        value=value,
+        method=method,
+        axis=axis,
+        limit=limit,
+        downcast=downcast,
+        output_types=get_output_types(df),
+    )
+    out_df = op(df, value_df=value_df)
+    if inplace:
+        df.data = out_df.data
+    else:
+        return out_df
+
+
+def ffill(df, axis=None, inplace=False, limit=None, downcast=None):
+    """
+    Synonym for :meth:`DataFrame.fillna` with ``method='ffill'``.
+
+    Returns
+    -------
+    {klass} or None
+        Object with missing values filled or None if ``inplace=True``.
+    """
+    return fillna(
+        df, method="ffill", axis=axis, inplace=inplace, limit=limit, downcast=downcast
+    )
+
+
+def bfill(df, axis=None, inplace=False, limit=None, downcast=None):
+    """
+    Synonym for :meth:`DataFrame.fillna` with ``method='bfill'``.
+
+    Returns
+    -------
+    {klass} or None
+        Object with missing values filled or None if ``inplace=True``.
+    """
+    return fillna(
+        df, method="bfill", axis=axis, inplace=inplace, limit=limit, downcast=downcast
+    )
+
+
+def index_fillna(index, value=None, downcast=None):
+    """
+    Fill NA/NaN values with the specified value.
+
+    Parameters
+    ----------
+    value : scalar
+        Scalar value to use to fill holes (e.g. 0).
+        This value cannot be a list-likes.
+    downcast : dict, default is None
+        A dict of item->dtype of what to downcast if possible,
+        or the string 'infer' which will try to downcast to an appropriate
+        equal type (e.g. float64 to int64 if possible).
+
+    Returns
+    -------
+    Index
+
+    See Also
+    --------
+    DataFrame.fillna : Fill NaN values of a DataFrame.
+    Series.fillna : Fill NaN Values of a Series.
+    """
+    if isinstance(value, (list, pd.Series, SERIES_TYPE)):
+        raise ValueError("'value' must be a scalar, passed: %s" % type(value))
+
+    op = FillNA(
+        value=value,
+        downcast=downcast,
+        output_types=get_output_types(index),
+    )
+    return op(index)