maxframe 2.0.0b2__cp310-cp310-macosx_10_9_universal2.whl → 2.2.0__cp310-cp310-macosx_10_9_universal2.whl

maxframe/dataframe/indexing/truncate.py

@@ -0,0 +1,140 @@
+# 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 ..utils import validate_axis
+
+
+def truncate(df, before=None, after=None, axis=0, copy=None):
+    """
+    Truncate a Series or DataFrame before and after some index value.
+
+    This is a useful shorthand for boolean indexing based on index
+    values above or below certain thresholds.
+
+    Parameters
+    ----------
+    before : date, str, int
+        Truncate all rows before this index value.
+    after : date, str, int
+        Truncate all rows after this index value.
+    axis : {0 or 'index', 1 or 'columns'}, optional
+        Axis to truncate. Truncates the index (rows) by default.
+        For `Series` this parameter is unused and defaults to 0.
+    copy : bool, default is True,
+        This parameter is only kept for compatibility with pandas.
+
+    Returns
+    -------
+    type of caller
+        The truncated Series or DataFrame.
+
+    See Also
+    --------
+    DataFrame.loc : Select a subset of a DataFrame by label.
+    DataFrame.iloc : Select a subset of a DataFrame by position.
+
+    Notes
+    -----
+    If the index being truncated contains only datetime values,
+    `before` and `after` may be specified as strings instead of
+    Timestamps.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame({'A': ['a', 'b', 'c', 'd', 'e'],
+    ...                    'B': ['f', 'g', 'h', 'i', 'j'],
+    ...                    'C': ['k', 'l', 'm', 'n', 'o']},
+    ...                   index=[1, 2, 3, 4, 5])
+    >>> df.execute()
+       A  B  C
+    1  a  f  k
+    2  b  g  l
+    3  c  h  m
+    4  d  i  n
+    5  e  j  o
+
+    >>> df.truncate(before=2, after=4).execute()
+       A  B  C
+    2  b  g  l
+    3  c  h  m
+    4  d  i  n
+
+    The columns of a DataFrame can be truncated.
+
+    >>> df.truncate(before="A", after="B", axis="columns").execute()
+       A  B
+    1  a  f
+    2  b  g
+    3  c  h
+    4  d  i
+    5  e  j
+
+    For Series, only rows can be truncated.
+
+    >>> df['A'].truncate(before=2, after=4).execute()
+    2    b
+    3    c
+    4    d
+    Name: A, dtype: object
+
+    The index values in ``truncate`` can be datetimes or string
+    dates.
+
+    >>> dates = md.date_range('2016-01-01', '2016-02-01', freq='s')
+    >>> df = md.DataFrame(index=dates, data={'A': 1})
+    >>> df.tail().execute()
+                         A
+    2016-01-31 23:59:56  1
+    2016-01-31 23:59:57  1
+    2016-01-31 23:59:58  1
+    2016-01-31 23:59:59  1
+    2016-02-01 00:00:00  1
+
+    >>> df.truncate(before=md.Timestamp('2016-01-05'),
+    ...             after=md.Timestamp('2016-01-10')).tail().execute()
+                         A
+    2016-01-09 23:59:56  1
+    2016-01-09 23:59:57  1
+    2016-01-09 23:59:58  1
+    2016-01-09 23:59:59  1
+    2016-01-10 00:00:00  1
+
+    Because the index is a DatetimeIndex containing only dates, we can
+    specify `before` and `after` as strings. They will be coerced to
+    Timestamps before truncation.
+
+    >>> df.truncate('2016-01-05', '2016-01-10').tail().execute()
+                         A
+    2016-01-09 23:59:56  1
+    2016-01-09 23:59:57  1
+    2016-01-09 23:59:58  1
+    2016-01-09 23:59:59  1
+    2016-01-10 00:00:00  1
+
+    Note that ``truncate`` assumes a 0 value for any unspecified time
+    component (midnight). This differs from partial string slicing, which
+    returns any partially matching dates.
+
+    >>> df.loc['2016-01-05':'2016-01-10', :].tail().execute()
+                         A
+    2016-01-10 23:59:55  1
+    2016-01-10 23:59:56  1
+    2016-01-10 23:59:57  1
+    2016-01-10 23:59:58  1
+    2016-01-10 23:59:59  1
+    """
+    _ = copy
+    axis = validate_axis(axis, df)
+    return df.loc[before:after, :] if axis == 0 else df.loc[:, before:after]

maxframe/dataframe/indexing/where.py

@@ -79,8 +79,6 @@ class DataFrameWhere(DataFrameOperator, DataFrameOperatorMixin):
             other=mock_other,
             axis=self.axis,
             level=self.level,
-            errors=self.errors,
-            try_cast=self.try_cast,
         )
 
         inputs = filter_inputs([df_or_series, self.cond, self.other])
@@ -135,15 +133,6 @@ axis : int, default None
     Alignment axis if needed.
 level : int, default None
     Alignment level if needed.
-errors : str, {{'raise', 'ignore'}}, default 'raise'
-    Note that currently this parameter won't affect
-    the results and will always coerce to a suitable dtype.
-
-    - 'raise' : allow exceptions to be raised.
-    - 'ignore' : suppress exceptions. On error return original object.
-
-try_cast : bool, default False
-    Try to cast the result back to the input type (if possible).
 
 Returns
 -------

maxframe/dataframe/indexing/xs.py

@@ -0,0 +1,148 @@
+# 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 pandas.api.types import is_list_like
+
+from ..utils import validate_axis
+
+
+def xs(df_or_series, key, axis=0, level=None, drop_level=True):
+    """
+    Return cross-section from the Series/DataFrame.
+
+    This method takes a `key` argument to select data at a particular
+    level of a MultiIndex.
+
+    Parameters
+    ----------
+    key : label or tuple of label
+        Label contained in the index, or partially in a MultiIndex.
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+        Axis to retrieve cross-section on.
+    level : object, defaults to first n levels (n=1 or len(key))
+        In case of a key partially contained in a MultiIndex, indicate
+        which levels are used. Levels can be referred by label or position.
+    drop_level : bool, default True
+        If False, returns object with same levels as self.
+
+    Returns
+    -------
+    Series or DataFrame
+        Cross-section from the original Series or DataFrame
+        corresponding to the selected index levels.
+
+    See Also
+    --------
+    DataFrame.loc : Access a group of rows and columns
+        by label(s) or a boolean array.
+    DataFrame.iloc : Purely integer-location based indexing
+        for selection by position.
+
+    Notes
+    -----
+    `xs` can not be used to set values.
+
+    MultiIndex Slicers is a generic way to get/set values on
+    any level or levels.
+    It is a superset of `xs` functionality, see
+    :ref:`MultiIndex Slicers <advanced.mi_slicers>`.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> d = {'num_legs': [4, 4, 2, 2],
+    ...      'num_wings': [0, 0, 2, 2],
+    ...      'class': ['mammal', 'mammal', 'mammal', 'bird'],
+    ...      'animal': ['cat', 'dog', 'bat', 'penguin'],
+    ...      'locomotion': ['walks', 'walks', 'flies', 'walks']}
+    >>> df = md.DataFrame(data=d)
+    >>> df = df.set_index(['class', 'animal', 'locomotion'])
+    >>> df.execute()
+                                num_legs  num_wings
+    class  animal  locomotion
+    mammal cat     walks              4          0
+            dog     walks              4          0
+            bat     flies              2          2
+    bird   penguin walks              2          2
+
+    Get values at specified index
+
+    >>> df.xs('mammal').execute()
+                        num_legs  num_wings
+    animal locomotion
+    cat    walks              4          0
+    dog    walks              4          0
+    bat    flies              2          2
+
+    Get values at several indexes
+
+    >>> df.xs(('mammal', 'dog')).execute()
+                num_legs  num_wings
+    locomotion
+    walks              4          0
+
+    Get values at specified index and level
+
+    >>> df.xs('cat', level=1).execute()
+                        num_legs  num_wings
+    class  locomotion
+    mammal walks              4          0
+
+    Get values at several indexes and levels
+
+    >>> df.xs(('bird', 'walks'),
+    ...       level=[0, 'locomotion']).execute()
+                num_legs  num_wings
+    animal
+    penguin         2          2
+
+    Get values at specified column and axis
+
+    >>> df.xs('num_wings', axis=1).execute()
+    class   animal   locomotion
+    mammal  cat      walks         0
+            dog      walks         0
+            bat      flies         2
+    bird    penguin  walks         2
+    Name: num_wings, dtype: int64
+    """
+    axis = validate_axis(axis, df_or_series)
+    if level is None:
+        level = range(df_or_series.axes[axis].nlevels)
+    elif not is_list_like(level):
+        level = [level]
+
+    slc = [slice(None)] * df_or_series.axes[axis].nlevels
+    if not is_list_like(key):
+        key = (key,)
+
+    level_set = set()
+    for k, level_ in zip(key, level):
+        slc[level_] = k
+        level_set.add(level_)
+    left_levels = set(range(df_or_series.axes[axis].nlevels)) - level_set
+
+    if len(slc) > 1:
+        slc = tuple(slc)
+
+    res = df_or_series.loc(axis=axis)[slc]
+    if drop_level:
+        if len(left_levels) == 0:
+            if res.ndim > 1:
+                res = res.iloc[0, :] if axis == 0 else res.iloc[:, 0]
+            else:
+                res = res.iloc[0]
+        else:
+            res = res.droplevel(list(level_set), axis=axis)
+    return res

maxframe/dataframe/merge/__init__.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .append import DataFrameAppend, append
+from .append import append
+from .combine_first import df_combine_first, series_combine_first
+from .compare import DataFrameCompare, df_compare, series_compare
 from .concat import DataFrameConcat, concat
 from .merge import (
     DataFrameMerge,
@@ -22,14 +24,23 @@ from .merge import (
     join,
     merge,
 )
+from .update import DataFrameUpdate, df_update, series_update
 
 
 def _install():
     from ..core import DATAFRAME_TYPE, SERIES_TYPE
 
     for cls in DATAFRAME_TYPE:
+        setattr(cls, "combine_first", df_combine_first)
+        setattr(cls, "compare", df_compare)
         setattr(cls, "join", join)
         setattr(cls, "merge", merge)
+        setattr(cls, "update", df_update)
+
+    for cls in SERIES_TYPE:
+        setattr(cls, "combine_first", series_combine_first)
+        setattr(cls, "compare", series_compare)
+        setattr(cls, "update", series_update)
 
     for cls in DATAFRAME_TYPE + SERIES_TYPE:
         setattr(cls, "append", append)

maxframe/dataframe/merge/append.py

@@ -14,108 +14,107 @@
 
 import pandas as pd
 
-from ... import opcodes
-from ...core import OutputType
-from ...serialization.serializables import BoolField
 from ..datasource.dataframe import from_pandas
-from ..operators import (
-    DATAFRAME_TYPE,
-    SERIES_TYPE,
-    DataFrameOperator,
-    DataFrameOperatorMixin,
-)
-from ..utils import parse_index
-
-
-class DataFrameAppend(DataFrameOperator, DataFrameOperatorMixin):
-    _op_type_ = opcodes.APPEND
-
-    ignore_index = BoolField("ignore_index", default=False)
-    verify_integrity = BoolField("verify_integrity", default=False)
-    sort = BoolField("sort", default=False)
-
-    def __init__(self, output_types=None, **kw):
-        super().__init__(_output_types=output_types, **kw)
-
-    def _call_dataframe(self, df, other):
-        if isinstance(other, DATAFRAME_TYPE):
-            shape = (df.shape[0] + other.shape[0], df.shape[1])
-            inputs = [df, other]
-            if self.ignore_index:
-                index_value = parse_index(pd.RangeIndex(shape[0]))
-            else:
-                index_value = parse_index(
-                    df.index_value.to_pandas().append(other.index_value.to_pandas())
-                )
-        elif isinstance(other, list):
-            row_length = df.shape[0]
-            index = df.index_value.to_pandas()
-            for item in other:
-                if not isinstance(item, DATAFRAME_TYPE):  # pragma: no cover
-                    raise ValueError(f"Invalid type {type(item)} to append")
-                row_length += item.shape[0]
-                index = index.append(item.index_value.to_pandas())
-            shape = (row_length, df.shape[1])
-            if self.ignore_index:  # pragma: no cover
-                index_value = parse_index(pd.RangeIndex(shape[0]))
-            else:
-                index_value = parse_index(index)
-            inputs = [df] + other
-        else:  # pragma: no cover
-            raise ValueError(f"Invalid type {type(other)} to append")
-        return self.new_dataframe(
-            inputs,
-            shape=shape,
-            dtypes=df.dtypes,
-            index_value=index_value,
-            columns_value=df.columns_value,
-        )
-
-    def _call_series(self, df, other):
-        if isinstance(other, SERIES_TYPE):
-            shape = (df.shape[0] + other.shape[0],)
-            inputs = [df, other]
-            if self.ignore_index:
-                index_value = parse_index(pd.RangeIndex(shape[0]))
-            else:
-                index_value = parse_index(
-                    df.index_value.to_pandas().append(other.index_value.to_pandas())
-                )
-        elif isinstance(other, list):
-            row_length = df.shape[0]
-            index = df.index_value.to_pandas()
-            for item in other:
-                if not isinstance(item, SERIES_TYPE):  # pragma: no cover
-                    raise ValueError(f"Invalid type {type(item)} to append")
-                row_length += item.shape[0]
-                index = index.append(item.index_value.to_pandas())
-            shape = (row_length,)
-            if self.ignore_index:  # pragma: no cover
-                index_value = parse_index(pd.RangeIndex(shape[0]))
-            else:
-                index_value = parse_index(index)
-            inputs = [df] + other
-        else:  # pragma: no cover
-            raise ValueError(f"Invalid type {type(other)} to append")
-        return self.new_series(
-            inputs, shape=shape, dtype=df.dtype, index_value=index_value, name=df.name
-        )
-
-    def __call__(self, df, other):
-        if isinstance(df, DATAFRAME_TYPE):
-            self.output_types = [OutputType.dataframe]
-            return self._call_dataframe(df, other)
-        else:
-            self.output_types = [OutputType.series]
-            return self._call_series(df, other)
 
 
 def append(df, other, ignore_index=False, verify_integrity=False, sort=False):
-    if verify_integrity or sort:  # pragma: no cover
-        raise NotImplementedError("verify_integrity and sort are not supported now")
+    """
+    Append rows of `other` to the end of caller, returning a new object.
+
+    Columns in `other` that are not in the caller are added as new columns.
+
+    Parameters
+    ----------
+    other : DataFrame or Series/dict-like object, or list of these
+        The data to append.
+    ignore_index : bool, default False
+        If True, the resulting axis will be labeled 0, 1, …, n - 1.
+    verify_integrity : bool, default False
+        If True, raise ValueError on creating index with duplicates.
+    sort : bool, default False
+        Sort columns if the columns of `self` and `other` are not aligned.
+
+    Returns
+    -------
+    DataFrame
+        A new DataFrame consisting of the rows of caller and the rows of `other`.
+
+    See Also
+    --------
+    concat : General function to concatenate DataFrame or Series objects.
+
+    Notes
+    -----
+    If a list of dict/series is passed and the keys are all contained in
+    the DataFrame's index, the order of the columns in the resulting
+    DataFrame will be unchanged.
+
+    Iteratively appending rows to a DataFrame can be more computationally
+    intensive than a single concatenate. A better solution is to append
+    those rows to a list and then concatenate the list with the original
+    DataFrame all at once.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([[1, 2], [3, 4]], columns=list('AB'), index=['x', 'y'])
+    >>> df.execute()
+       A  B
+    x  1  2
+    y  3  4
+    >>> df2 = md.DataFrame([[5, 6], [7, 8]], columns=list('AB'), index=['x', 'y'])
+    >>> df.append(df2).execute()
+       A  B
+    x  1  2
+    y  3  4
+    x  5  6
+    y  7  8
+
+    With `ignore_index` set to True:
+
+    >>> df.append(df2, ignore_index=True).execute()
+       A  B
+    0  1  2
+    1  3  4
+    2  5  6
+    3  7  8
+
+    The following, while not recommended methods for generating DataFrames,
+    show two ways to generate a DataFrame from multiple data sources.
+
+    Less efficient:
+
+    >>> df = md.DataFrame(columns=['A'])
+    >>> for i in range(5):
+    ...     df = df.append({'A': i}, ignore_index=True)
+    >>> df.execute()
+       A
+    0  0
+    1  1
+    2  2
+    3  3
+    4  4
+
+    More efficient:
+
+    >>> md.concat([md.DataFrame([i], columns=['A']) for i in range(5)],
+    ...           ignore_index=True).execute()
+       A
+    0  0
+    1  1
+    2  2
+    3  3
+    4  4
+    """
+    from .concat import concat
+
     if isinstance(other, dict):
         other = from_pandas(pd.DataFrame(dict((k, [v]) for k, v in other.items())))
-    op = DataFrameAppend(
-        ignore_index=ignore_index, verify_integrity=verify_integrity, sort=sort
+    if not isinstance(other, list):
+        other = [other]
+    return concat(
+        [df] + other,
+        ignore_index=ignore_index,
+        verify_integrity=verify_integrity,
+        sort=sort,
     )
-    return op(df, other)

maxframe/dataframe/merge/combine_first.py

@@ -0,0 +1,120 @@
+# 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.
+
+
+def df_combine_first(df, other):
+    """
+    Update null elements with value in the same location in `other`.
+
+    Combine two DataFrame objects by filling null values in one DataFrame
+    with non-null values from other DataFrame. The row and column indexes
+    of the resulting DataFrame will be the union of the two. The resulting
+    dataframe contains the 'first' dataframe values and overrides the
+    second one values where both first.loc[index, col] and
+    second.loc[index, col] are not missing values, upon calling
+    first.combine_first(second).
+
+    Parameters
+    ----------
+    other : DataFrame
+        Provided DataFrame to use to fill null values.
+
+    Returns
+    -------
+    DataFrame
+        The result of combining the provided DataFrame with the other object.
+
+    See Also
+    --------
+    DataFrame.combine : Perform series-wise operation on two DataFrames
+        using a given function.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df1 = md.DataFrame({'A': [None, 0], 'B': [None, 4]})
+    >>> df2 = md.DataFrame({'A': [1, 1], 'B': [3, 3]})
+    >>> df1.combine_first(df2).execute()
+         A    B
+    0  1.0  3.0
+    1  0.0  4.0
+
+    Null values still persist if the location of that null value
+    does not exist in `other`
+
+    >>> df1 = md.DataFrame({'A': [None, 0], 'B': [4, None]})
+    >>> df2 = md.DataFrame({'B': [3, 3], 'C': [1, 1]}, index=[1, 2])
+    >>> df1.combine_first(df2).execute()
+         A    B    C
+    0  NaN  4.0  NaN
+    1  0.0  3.0  1.0
+    2  NaN  3.0  1.0
+    """
+    ret = df.copy()
+    ret.update(other, join="outer", overwrite=False)
+    return ret
+
+
+def series_combine_first(series, other):
+    """
+    Update null elements with value in the same location in 'other'.
+
+    Combine two Series objects by filling null values in one Series with
+    non-null values from the other Series. Result index will be the union
+    of the two indexes.
+
+    Parameters
+    ----------
+    other : Series
+        The value(s) to be used for filling null values.
+
+    Returns
+    -------
+    Series
+        The result of combining the provided Series with the other object.
+
+    See Also
+    --------
+    Series.combine : Perform element-wise operation on two Series
+        using a given function.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> s1 = md.Series([1, mt.nan])
+    >>> s2 = md.Series([3, 4, 5])
+    >>> s1.combine_first(s2).execute()
+    0    1.0
+    1    4.0
+    2    5.0
+    dtype: float64
+
+    Null values still persist if the location of that null value
+    does not exist in `other`
+
+    >>> s1 = md.Series({'falcon': mt.nan, 'eagle': 160.0})
+    >>> s2 = md.Series({'eagle': 200.0, 'duck': 30.0})
+    >>> s1.combine_first(s2).execute()
+    duck       30.0
+    eagle     160.0
+    falcon      NaN
+    dtype: float64
+    """
+    ret = series.copy()
+    # as Series.update does not have other args, we add them manually
+    #  to the operator object
+    ret.update(other)
+    ret.op.join, ret.op.overwrite = "outer", False
+    return ret