maxframe 0.1.0b5__cp38-cp38-macosx_11_0_arm64.whl

maxframe/dataframe/misc/pct_change.py

@@ -0,0 +1,150 @@
+# 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 ..utils import validate_axis
+
+
+def pct_change(
+    df_or_series, periods=1, fill_method="pad", limit=None, freq=None, **kwargs
+):
+    """
+    Percentage change between the current and a prior element.
+
+    Computes the percentage change from the immediately previous row by
+    default. This is useful in comparing the percentage of change in a time
+    series of elements.
+
+    Parameters
+    ----------
+    periods : int, default 1
+        Periods to shift for forming percent change.
+    fill_method : str, default 'pad'
+        How to handle NAs before computing percent changes.
+    limit : int, default None
+        The number of consecutive NAs to fill before stopping.
+    freq : DateOffset, timedelta, or str, optional
+        Increment to use from time series API (e.g. 'M' or BDay()).
+    **kwargs
+        Additional keyword arguments are passed into
+        `DataFrame.shift` or `Series.shift`.
+
+    Returns
+    -------
+    chg : Series or DataFrame
+        The same type as the calling object.
+
+    See Also
+    --------
+    Series.diff : Compute the difference of two elements in a Series.
+    DataFrame.diff : Compute the difference of two elements in a DataFrame.
+    Series.shift : Shift the index by some number of periods.
+    DataFrame.shift : Shift the index by some number of periods.
+
+    Examples
+    --------
+    **Series**
+
+    >>> import maxframe.dataframe as md
+
+    >>> s = md.Series([90, 91, 85])
+    >>> s.execute()
+    0    90
+    1    91
+    2    85
+    dtype: int64
+
+    >>> s.pct_change().execute()
+    0         NaN
+    1    0.011111
+    2   -0.065934
+    dtype: float64
+
+    >>> s.pct_change(periods=2).execute()
+    0         NaN
+    1         NaN
+    2   -0.055556
+    dtype: float64
+
+    See the percentage change in a Series where filling NAs with last
+    valid observation forward to next valid.
+
+    >>> s = md.Series([90, 91, None, 85])
+    >>> s.execute()
+    0    90.0
+    1    91.0
+    2     NaN
+    3    85.0
+    dtype: float64
+
+    >>> s.pct_change(fill_method='ffill').execute()
+    0         NaN
+    1    0.011111
+    2    0.000000
+    3   -0.065934
+    dtype: float64
+
+    **DataFrame**
+
+    Percentage change in French franc, Deutsche Mark, and Italian lira from
+    1980-01-01 to 1980-03-01.
+
+    >>> df = md.DataFrame({
+    ...     'FR': [4.0405, 4.0963, 4.3149],
+    ...     'GR': [1.7246, 1.7482, 1.8519],
+    ...     'IT': [804.74, 810.01, 860.13]},
+    ...     index=['1980-01-01', '1980-02-01', '1980-03-01'])
+    >>> df.execute()
+                    FR      GR      IT
+    1980-01-01  4.0405  1.7246  804.74
+    1980-02-01  4.0963  1.7482  810.01
+    1980-03-01  4.3149  1.8519  860.13
+
+    >>> df.pct_change().execute()
+                      FR        GR        IT
+    1980-01-01       NaN       NaN       NaN
+    1980-02-01  0.013810  0.013684  0.006549
+    1980-03-01  0.053365  0.059318  0.061876
+
+    Percentage of change in GOOG and APPL stock volume. Shows computing
+    the percentage change between columns.
+
+    >>> df = md.DataFrame({
+    ...     '2016': [1769950, 30586265],
+    ...     '2015': [1500923, 40912316],
+    ...     '2014': [1371819, 41403351]},
+    ...     index=['GOOG', 'APPL'])
+    >>> df.execute()
+              2016      2015      2014
+    GOOG   1769950   1500923   1371819
+    APPL  30586265  40912316  41403351
+
+    >>> df.pct_change(axis='columns').execute()
+          2016      2015      2014
+    GOOG   NaN -0.151997 -0.086016
+    APPL   NaN  0.337604  0.012002
+    """
+
+    axis = validate_axis(kwargs.pop("axis", 0))
+    if fill_method is None:
+        data = df_or_series
+    else:
+        data = df_or_series.fillna(method=fill_method, axis=axis, limit=limit)
+
+    rs = data.div(data.shift(periods=periods, freq=freq, axis=axis, **kwargs)) - 1
+    if freq is not None:
+        # Shift method is implemented differently when freq is not None
+        # We want to restore the original index
+        rs = rs.loc[~rs.index.duplicated()]
+        rs = rs.reindex_like(data)
+    return rs

maxframe/dataframe/misc/pivot_table.py

@@ -0,0 +1,262 @@
+# 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, BoolField, StringField
+from ...utils import no_default
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import build_df, parse_index
+
+
+class DataFramePivotTable(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.PIVOT_TABLE
+
+    values = AnyField("values", default=None)
+    index = AnyField("index", default=None)
+    columns = AnyField("columns", default=None)
+    aggfunc = AnyField("aggfunc", default="mean")
+    fill_value = AnyField("fill_value", default=None)
+    margins = BoolField("margins", default=False)
+    dropna = BoolField("dropna", default=True)
+    margins_name = StringField("margins_name", default=None)
+    sort = BoolField("sort", default=False)
+
+    def __init__(self, **kw):
+        super().__init__(**kw)
+        self.output_types = [OutputType.dataframe]
+
+    def __call__(self, df):
+        index_value = columns_value = dtypes = None
+        if self.index is not None:
+            # index is now a required field
+            if len(self.index) == 1:
+                index_data = pd.Index(
+                    [], dtype=df.dtypes[self.index[0]], name=self.index[0]
+                )
+            else:
+                index_data = pd.MultiIndex.from_frame(build_df(df[self.index]))
+            index_value = parse_index(index_data)
+
+            if self.columns is None:  # output columns can be determined
+                sel_df = df
+                groupby_obj = sel_df.groupby(self.index)
+                if self.values:
+                    groupby_obj = groupby_obj[self.values]
+                aggregated_df = groupby_obj.agg(self.aggfunc)
+                index_value = aggregated_df.index_value
+                columns_value = aggregated_df.columns_value
+                dtypes = aggregated_df.dtypes
+            else:
+                columns_value = dtypes = None
+        return self.new_dataframe(
+            [df],
+            shape=(np.nan, np.nan),
+            dtypes=dtypes,
+            columns_value=columns_value,
+            index_value=index_value,
+        )
+
+
+def pivot_table(
+    data,
+    values=None,
+    index=None,
+    columns=None,
+    aggfunc="mean",
+    fill_value=None,
+    margins=False,
+    dropna=True,
+    margins_name="All",
+    sort=True,
+):
+    """
+    Create a spreadsheet-style pivot table as a DataFrame.
+
+    The levels in the pivot table will be stored in MultiIndex objects
+    (hierarchical indexes) on the index and columns of the result DataFrame.
+
+    Parameters
+    ----------
+    values : column to aggregate, optional
+    index : column, Grouper, array, or list of the previous
+        If an array is passed, it must be the same length as the data. The
+        list can contain any of the other types (except list).
+        Keys to group by on the pivot table index.  If an array is passed,
+        it is being used as the same manner as column values.
+    columns : column, Grouper, array, or list of the previous
+        If an array is passed, it must be the same length as the data. The
+        list can contain any of the other types (except list).
+        Keys to group by on the pivot table column.  If an array is passed,
+        it is being used as the same manner as column values.
+    aggfunc : function, list of functions, dict, default numpy.mean
+        If list of functions passed, the resulting pivot table will have
+        hierarchical columns whose top level are the function names
+        (inferred from the function objects themselves)
+        If dict is passed, the key is column to aggregate and value
+        is function or list of functions.
+    fill_value : scalar, default None
+        Value to replace missing values with (in the resulting pivot table,
+        after aggregation).
+    margins : bool, default False
+        Add all row / columns (e.g. for subtotal / grand totals).
+    dropna : bool, default True
+        Do not include columns whose entries are all NaN.
+    margins_name : str, default 'All'
+        Name of the row / column that will contain the totals
+        when margins is True.
+    sort : bool, default True
+        Specifies if the result should be sorted.
+
+    Returns
+    -------
+    DataFrame
+        An Excel style pivot table.
+
+    See Also
+    --------
+    DataFrame.pivot : Pivot without aggregation that can handle
+        non-numeric data.
+    DataFrame.melt: Unpivot a DataFrame from wide to long format,
+        optionally leaving identifiers set.
+    wide_to_long : Wide panel to long format. Less flexible but more
+        user-friendly than melt.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({"A": ["foo", "foo", "foo", "foo", "foo",
+    ...                          "bar", "bar", "bar", "bar"],
+    ...                    "B": ["one", "one", "one", "two", "two",
+    ...                          "one", "one", "two", "two"],
+    ...                    "C": ["small", "large", "large", "small",
+    ...                          "small", "large", "small", "small",
+    ...                          "large"],
+    ...                    "D": [1, 2, 2, 3, 3, 4, 5, 6, 7],
+    ...                    "E": [2, 4, 5, 5, 6, 6, 8, 9, 9]})
+    >>> df.execute()
+         A    B      C  D  E
+    0  foo  one  small  1  2
+    1  foo  one  large  2  4
+    2  foo  one  large  2  5
+    3  foo  two  small  3  5
+    4  foo  two  small  3  6
+    5  bar  one  large  4  6
+    6  bar  one  small  5  8
+    7  bar  two  small  6  9
+    8  bar  two  large  7  9
+
+    This first example aggregates values by taking the sum.
+
+    >>> table = md.pivot_table(df, values='D', index=['A', 'B'],
+    ...                        columns=['C'], aggfunc=np.sum)
+    >>> table.execute()
+    C        large  small
+    A   B
+    bar one    4.0    5.0
+        two    7.0    6.0
+    foo one    4.0    1.0
+        two    NaN    6.0
+
+    We can also fill missing values using the `fill_value` parameter.
+
+    >>> table = md.pivot_table(df, values='D', index=['A', 'B'],
+    ...                        columns=['C'], aggfunc=np.sum, fill_value=0)
+    >>> table.execute()
+    C        large  small
+    A   B
+    bar one      4      5
+        two      7      6
+    foo one      4      1
+        two      0      6
+
+    The next example aggregates by taking the mean across multiple columns.
+
+    >>> table = md.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
+    ...                        aggfunc={'D': np.mean,
+    ...                                 'E': np.mean})
+    >>> table.execute()
+                    D         E
+    A   C
+    bar large  5.500000  7.500000
+        small  5.500000  8.500000
+    foo large  2.000000  4.500000
+        small  2.333333  4.333333
+
+    We can also calculate multiple types of aggregations for any given
+    value column.
+
+    >>> table = md.pivot_table(df, values=['D', 'E'], index=['A', 'C'],
+    ...                        aggfunc={'D': np.mean,
+    ...                                 'E': [min, max, np.mean]})
+    >>> table.execute()
+                    D    E
+                mean  max      mean  min
+    A   C
+    bar large  5.500000  9.0  7.500000  6.0
+        small  5.500000  9.0  8.500000  8.0
+    foo large  2.000000  5.0  4.500000  4.0
+        small  2.333333  6.0  4.333333  2.0
+    """
+    if index is None and columns is None:
+        raise ValueError(
+            "No group keys passed, need to specify at least one of index or columns"
+        )
+
+    def make_col_list(col):
+        try:
+            if col in data.dtypes.index:
+                return [col]
+        except TypeError:
+            return col
+        return col
+
+    values_list = make_col_list(values)
+    index_list = make_col_list(index)
+    columns_list = make_col_list(columns)
+
+    name_to_attr = {"values": values_list, "index": index_list, "columns": columns_list}
+    for key, val in name_to_attr.items():
+        if val is None:
+            continue
+        if not is_list_like(val):
+            raise ValueError(f"Need to specify {key} as a list-like object.")
+        non_exist_key = next((c for c in val if c not in data.dtypes.index), no_default)
+        if non_exist_key is not no_default:
+            raise ValueError(
+                f"Column {non_exist_key} specified in {key} is not a valid column."
+            )
+
+    if columns is None and not margins:
+        if values_list:
+            data = data[index_list + values_list]
+        return data.groupby(index, sort=sort).agg(aggfunc)
+
+    op = DataFramePivotTable(
+        values=values,
+        index=index,
+        columns=columns,
+        aggfunc=aggfunc,
+        fill_value=fill_value,
+        margins=margins,
+        dropna=dropna,
+        margins_name=margins_name,
+        sort=sort,
+    )
+    return op(data)

maxframe/dataframe/misc/qcut.py

@@ -0,0 +1,104 @@
+# 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_integer
+
+from ...core import ENTITY_TYPE
+from ...tensor import tensor as astensor
+from ...tensor.statistics.percentile import percentile
+from ..core import DATAFRAME_TYPE, SERIES_TYPE
+from ..initializer import DataFrame, Series
+from .cut import cut
+
+
+def qcut(x, q, labels=None, retbins=False, precision=3, duplicate="raise"):
+    """
+    Quantile-based discretization function.
+
+    Discretize variable into equal-sized buckets based on rank or based
+    on sample quantiles. For example 1000 values for 10 quantiles would
+    produce a Categorical object indicating quantile membership for each data point.
+
+    Parameters
+    ----------
+    x : 1d tensor or Series
+    q : int or list-like of float
+        Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately
+        array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.
+    labels : array or False, default None
+        Used as labels for the resulting bins. Must be of the same length as
+        the resulting bins. If False, return only integer indicators of the
+        bins. If True, raises an error.
+    retbins : bool, optional
+        Whether to return the (bins, labels) or not. Can be useful if bins
+        is given as a scalar.
+    precision : int, optional
+        The precision at which to store and display the bins labels.
+    duplicates : {default 'raise', 'drop'}, optional
+        If bin edges are not unique, raise ValueError or drop non-uniques.
+
+    Returns
+    -------
+    out : Categorical or Series or tensor of integers if labels is False
+        The return type (Categorical or Series) depends on the input: a Series
+        of type category if input is a Series else Categorical. Bins are
+        represented as categories when categorical data is returned.
+    bins : tensor of floats
+        Returned only if `retbins` is True.
+
+    Notes
+    -----
+    Out of bounds values will be NA in the resulting Categorical object
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> md.qcut(range(5), 4).execute()
+    ... # doctest: +ELLIPSIS
+    [(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]]
+    Categories (4, interval[float64]): [(-0.001, 1.0] < (1.0, 2.0] ...
+
+    >>> md.qcut(range(5), 3, labels=["good", "medium", "bad"]).execute()
+    ... # doctest: +SKIP
+    [good, good, medium, bad, bad]
+    Categories (3, object): [good < medium < bad]
+
+    >>> md.qcut(range(5), 4, labels=False).execute()
+    array([0, 0, 1, 2, 3])
+    """
+    if is_integer(q):
+        q = np.linspace(0, 1, q + 1)
+
+    if isinstance(x, (DATAFRAME_TYPE, SERIES_TYPE, pd.DataFrame, pd.Series)):
+        x = DataFrame(x) if x.ndim == 2 else Series(x)
+        bins = x.quantile(q)
+    else:
+        x = astensor(x)
+        if isinstance(q, ENTITY_TYPE):
+            q = q * 100
+        else:
+            q = [iq * 100 for iq in q]
+        bins = percentile(x, q)
+
+    return cut(
+        x,
+        bins,
+        labels=labels,
+        retbins=retbins,
+        precision=precision,
+        include_lowest=True,
+        duplicates=duplicate,
+    )

maxframe/dataframe/misc/select_dtypes.py

@@ -0,0 +1,104 @@
+# 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 ..utils import build_empty_df
+
+
+def select_dtypes(df, include=None, exclude=None):
+    """
+    Return a subset of the DataFrame's columns based on the column dtypes.
+
+    Parameters
+    ----------
+    include, exclude : scalar or list-like
+        A selection of dtypes or strings to be included/excluded. At least
+        one of these parameters must be supplied.
+
+    Returns
+    -------
+    DataFrame
+        The subset of the frame including the dtypes in ``include`` and
+        excluding the dtypes in ``exclude``.
+
+    Raises
+    ------
+    ValueError
+        * If both of ``include`` and ``exclude`` are empty
+        * If ``include`` and ``exclude`` have overlapping elements
+        * If any kind of string dtype is passed in.
+
+    See Also
+    --------
+    DataFrame.dtypes: Return Series with the data type of each column.
+
+    Notes
+    -----
+    * To select all *numeric* types, use ``np.number`` or ``'number'``
+    * To select strings you must use the ``object`` dtype, but note that
+      this will return *all* object dtype columns
+    * See the `numpy dtype hierarchy
+      <https://numpy.org/doc/stable/reference/arrays.scalars.html>`__
+    * To select datetimes, use ``np.datetime64``, ``'datetime'`` or
+      ``'datetime64'``
+    * To select timedeltas, use ``np.timedelta64``, ``'timedelta'`` or
+      ``'timedelta64'``
+    * To select Pandas categorical dtypes, use ``'category'``
+    * To select Pandas datetimetz dtypes, use ``'datetimetz'`` (new in
+      0.20.0) or ``'datetime64[ns, tz]'``
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'a': [1, 2] * 3,
+    ...                    'b': [True, False] * 3,
+    ...                    'c': [1.0, 2.0] * 3})
+    >>> df.execute()
+            a      b  c
+    0       1   True  1.0
+    1       2  False  2.0
+    2       1   True  1.0
+    3       2  False  2.0
+    4       1   True  1.0
+    5       2  False  2.0
+
+    >>> df.select_dtypes(include='bool').execute()
+       b
+    0  True
+    1  False
+    2  True
+    3  False
+    4  True
+    5  False
+
+    >>> df.select_dtypes(include=['float64']).execute()
+       c
+    0  1.0
+    1  2.0
+    2  1.0
+    3  2.0
+    4  1.0
+    5  2.0
+
+    >>> df.select_dtypes(exclude=['int64']).execute()
+           b    c
+    0   True  1.0
+    1  False  2.0
+    2   True  1.0
+    3  False  2.0
+    4   True  1.0
+    5  False  2.0
+    """
+    test_df = build_empty_df(df.dtypes)
+    test_df = test_df.select_dtypes(include=include, exclude=exclude)
+    return df[test_df.dtypes.index.tolist()]