maxframe 2.0.0b2__cp37-cp37m-win32.whl → 2.3.0rc1__cp37-cp37m-win32.whl

maxframe/dataframe/indexing/setitem.py

@@ -23,7 +23,7 @@ from ...core import EntityData, 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 ..core import DATAFRAME_TYPE, ENTITY_TYPE, SERIES_TYPE, DataFrame
 from ..initializer import DataFrame as asframe
 from ..initializer import Series as asseries
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
@@ -77,7 +77,7 @@ class DataFrameSetitem(DataFrameOperator, DataFrameOperatorMixin):
                 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):
+                if is_list_like(value) and not isinstance(value, ENTITY_TYPE):
                     value = np.array(value)
 
                 if value.ndim == 1:
@@ -108,7 +108,7 @@ class DataFrameSetitem(DataFrameOperator, DataFrameOperatorMixin):
 
         try:
             dtypes.loc[self.indexes] = value_dtype
-        except KeyError:
+        except (AttributeError, KeyError):
             # when some index not exist, try update one by one
             if isinstance(value_dtype, pd.Series):
                 for idx in self.indexes:

maxframe/dataframe/indexing/swaplevel.py

@@ -0,0 +1,185 @@
+# 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
+
+from ..utils import validate_axis
+
+
+def _swaplevel(df_or_series, i=-2, j=-1, axis=0):
+    axis = validate_axis(axis, df_or_series)
+
+    if axis == 0:
+        src_idx_value = df_or_series.index_value
+    else:
+        src_idx_value = df_or_series.columns_value
+
+    pd_index = src_idx_value.to_pandas()
+    if not isinstance(pd_index, pd.MultiIndex):
+        raise ValueError("swaplevel can only be used with MultiIndex")
+
+    name_to_idx = {name: idx for idx, name in enumerate(pd_index.names)}
+    src_idx, dest_idx = name_to_idx.get(i, i), name_to_idx.get(j, j)
+
+    new_idxes = list(range(len(pd_index.names)))
+    new_idxes[src_idx], new_idxes[dest_idx] = new_idxes[dest_idx], new_idxes[src_idx]
+    if df_or_series.ndim == 2:
+        return df_or_series.reorder_levels(new_idxes, axis=axis)
+    else:
+        return df_or_series.reorder_levels(new_idxes)
+
+
+def df_swaplevel(df, i=-2, j=-1, axis=0):
+    """
+    Swap levels i and j in a :class:`MultiIndex`.
+
+    Default is to swap the two innermost levels of the index.
+
+    Parameters
+    ----------
+    i, j : int or str
+        Levels of the indices to be swapped. Can pass level name as string.
+    axis : {0 or 'index', 1 or 'columns'}, default 0
+                The axis to swap levels on. 0 or 'index' for row-wise, 1 or
+                'columns' for column-wise.
+
+    Returns
+    -------
+    DataFrame
+        DataFrame with levels swapped in MultiIndex.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame(
+    ...     {"Grade": ["A", "B", "A", "C"]},
+    ...     index=[
+    ...         ["Final exam", "Final exam", "Coursework", "Coursework"],
+    ...         ["History", "Geography", "History", "Geography"],
+    ...         ["January", "February", "March", "April"],
+    ...     ],
+    ... )
+    >>> df.execute()
+                                        Grade
+    Final exam  History     January      A
+                Geography   February     B
+    Coursework  History     March        A
+                Geography   April        C
+
+    In the following example, we will swap the levels of the indices.
+    Here, we will swap the levels column-wise, but levels can be swapped row-wise
+    in a similar manner. Note that column-wise is the default behaviour.
+    By not supplying any arguments for i and j, we swap the last and second to
+    last indices.
+
+    >>> df.swaplevel().execute()
+                                        Grade
+    Final exam  January     History         A
+                February    Geography       B
+    Coursework  March       History         A
+                April       Geography       C
+
+    By supplying one argument, we can choose which index to swap the last
+    index with. We can for example swap the first index with the last one as
+    follows.
+
+    >>> df.swaplevel(0).execute()
+                                        Grade
+    January     History     Final exam      A
+    February    Geography   Final exam      B
+    March       History     Coursework      A
+    April       Geography   Coursework      C
+
+    We can also define explicitly which indices we want to swap by supplying values
+    for both i and j. Here, we for example swap the first and second indices.
+
+    >>> df.swaplevel(0, 1).execute()
+                                        Grade
+    History     Final exam  January         A
+    Geography   Final exam  February        B
+    History     Coursework  March           A
+    Geography   Coursework  April           C
+    """
+    return _swaplevel(df, i, j, axis=axis)
+
+
+def series_swaplevel(series, i=-2, j=-1):
+    """
+    Swap levels i and j in a :class:`MultiIndex`.
+
+    Default is to swap the two innermost levels of the index.
+
+    Parameters
+    ----------
+    i, j : int or str
+        Levels of the indices to be swapped. Can pass level name as string.
+
+    Returns
+    -------
+    Series
+        Series with levels swapped in MultiIndex.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> s = md.Series(
+    ...     ["A", "B", "A", "C"],
+    ...     index=[
+    ...         ["Final exam", "Final exam", "Coursework", "Coursework"],
+    ...         ["History", "Geography", "History", "Geography"],
+    ...         ["January", "February", "March", "April"],
+    ...     ],
+    ... )
+    >>> s.execute()
+    Final exam  History     January      A
+                Geography   February     B
+    Coursework  History     March        A
+                Geography   April        C
+    dtype: object
+
+    In the following example, we will swap the levels of the indices.
+    Here, we will swap the levels column-wise, but levels can be swapped row-wise
+    in a similar manner. Note that column-wise is the default behaviour.
+    By not supplying any arguments for i and j, we swap the last and second to
+    last indices.
+
+    >>> s.swaplevel().execute()
+    Final exam  January     History         A
+                February    Geography       B
+    Coursework  March       History         A
+                April       Geography       C
+    dtype: object
+
+    By supplying one argument, we can choose which index to swap the last
+    index with. We can for example swap the first index with the last one as
+    follows.
+
+    >>> s.swaplevel(0).execute()
+    January     History     Final exam      A
+    February    Geography   Final exam      B
+    March       History     Coursework      A
+    April       Geography   Coursework      C
+    dtype: object
+
+    We can also define explicitly which indices we want to swap by supplying values
+    for both i and j. Here, we for example swap the first and second indices.
+
+    >>> s.swaplevel(0, 1).execute()
+    History     Final exam  January         A
+    Geography   Final exam  February        B
+    History     Coursework  March           A
+    Geography   Coursework  April           C
+    dtype: object
+    """
+    return _swaplevel(series, i, j)

maxframe/dataframe/indexing/take.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.
+
+from ..utils import validate_axis
+
+
+def take(df_or_series, indices, axis=0, **kwargs):
+    """
+    Return the elements in the given *positional* indices along an axis.
+
+    This means that we are not indexing according to actual values in
+    the index attribute of the object. We are indexing according to the
+    actual position of the element in the object.
+
+    Parameters
+    ----------
+    indices : array-like
+        An array of ints indicating which positions to take.
+    axis : {0 or 'index', 1 or 'columns', None}, default 0
+        The axis on which to select elements. ``0`` means that we are
+        selecting rows, ``1`` means that we are selecting columns.
+        For `Series` this parameter is unused and defaults to 0.
+    **kwargs
+        For compatibility with :meth:`numpy.take`. Has no effect on the
+        output.
+
+    Returns
+    -------
+    same type as caller
+        An array-like containing the elements taken from the object.
+
+    See Also
+    --------
+    DataFrame.loc : Select a subset of a DataFrame by labels.
+    DataFrame.iloc : Select a subset of a DataFrame by positions.
+    numpy.take : Take elements from an array along an axis.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([('falcon', 'bird', 389.0),
+    ...                    ('parrot', 'bird', 24.0),
+    ...                    ('lion', 'mammal', 80.5),
+    ...                    ('monkey', 'mammal', mt.nan)],
+    ...                   columns=['name', 'class', 'max_speed'],
+    ...                   index=[0, 2, 3, 1])
+    >>> df.execute()
+         name   class  max_speed
+    0  falcon    bird      389.0
+    2  parrot    bird       24.0
+    3    lion  mammal       80.5
+    1  monkey  mammal        NaN
+
+    Take elements at positions 0 and 3 along the axis 0 (default).
+
+    Note how the actual indices selected (0 and 1) do not correspond to
+    our selected indices 0 and 3. That's because we are selecting the 0th
+    and 3rd rows, not rows whose indices equal 0 and 3.
+
+    >>> df.take([0, 3]).execute()
+         name   class  max_speed
+    0  falcon    bird      389.0
+    1  monkey  mammal        NaN
+
+    Take elements at indices 1 and 2 along the axis 1 (column selection).
+
+    >>> df.take([1, 2], axis=1).execute()
+        class  max_speed
+    0    bird      389.0
+    2    bird       24.0
+    3  mammal       80.5
+    1  mammal        NaN
+
+    We may take elements using negative integers for positive indices,
+    starting from the end of the object, just like with Python lists.
+
+    >>> df.take([-1, -2]).execute()
+         name   class  max_speed
+    1  monkey  mammal        NaN
+    3    lion  mammal       80.5
+    """
+    kwargs.clear()
+
+    axis = validate_axis(axis, df_or_series)
+    slc = [slice(None), slice(None)][: df_or_series.ndim]
+    slc[axis] = indices
+    return df_or_series.iloc[tuple(slc)]

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,10 @@
 # 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 import DataFrameCombine, df_combine, series_combine
+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 +25,25 @@ 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)
+        setattr(cls, "combine", df_combine)
+
+    for cls in SERIES_TYPE:
+        setattr(cls, "combine_first", series_combine_first)
+        setattr(cls, "compare", series_compare)
+        setattr(cls, "update", series_update)
+        setattr(cls, "combine", series_combine)
 
     for cls in DATAFRAME_TYPE + SERIES_TYPE:
         setattr(cls, "append", append)