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

maxframe/dataframe/indexing/filter.py

@@ -0,0 +1,169 @@
+# 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 re
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import get_output_types
+from ...serialization.serializables import Int32Field, ListField, StringField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+
+class DataFrameFilter(DataFrameOperatorMixin, DataFrameOperator):
+    _op_type_ = opcodes.DATAFRAME_FILTER
+
+    items = ListField("items", default=None)
+    like = StringField("like", default=None)
+    regex = StringField("regex", default=None)
+    axis = Int32Field("axis", default=None)
+
+    def __call__(self, df_or_series):
+        self._output_types = get_output_types(df_or_series)
+
+        # Get axis labels to filter
+        if self.axis == 0:
+            # Filter by index
+            labels = df_or_series.index_value.to_pandas()
+        else:
+            # Filter by columns (DataFrame only)
+            if not hasattr(df_or_series, "columns"):
+                raise ValueError("axis=1 (columns) not valid for Series")
+            labels = df_or_series.columns_value.to_pandas()
+
+        # Apply filter criteria
+        filtered_labels = self._apply_filter_criteria(labels)
+
+        # Calculate output shape and metadata
+        out_params = self._calculate_output_metadata(df_or_series, filtered_labels)
+        return self.new_tileable([df_or_series], **out_params)
+
+    def _apply_filter_criteria(self, labels):
+        """Apply filter criteria to labels"""
+        if self.items is not None:
+            # Exact match filter
+            return [label for label in labels if label in self.items]
+        elif self.like is not None:
+            # Substring match filter
+            return [label for label in labels if self.like in str(label)]
+        elif self.regex is not None:
+            # Regex match filter
+            pattern = re.compile(self.regex)
+            return [label for label in labels if pattern.search(str(label))]
+        else:
+            return list(labels)
+
+    def _calculate_output_metadata(self, input_tileable, filtered_labels):
+        input_shape = input_tileable.shape
+
+        out_params = input_tileable.params
+        if self.axis == 0:
+            out_params["shape"] = (len(filtered_labels) or np.nan,) + input_shape[1:]
+            out_params["index_value"] = parse_index(
+                pd.Index(filtered_labels), input_tileable.index_value
+            )
+        else:
+            out_params["shape"] = (input_shape[0], len(filtered_labels))
+            out_params["columns_value"] = parse_index(
+                input_tileable.dtypes[filtered_labels].index, store_data=True
+            )
+        return out_params
+
+
+def filter_dataframe(df_or_series, items=None, like=None, regex=None, axis=None):
+    """
+    Subset the dataframe rows or columns according to the specified index labels.
+
+    Note that this routine does not filter a dataframe on its
+    contents. The filter is applied to the labels of the index.
+
+    Parameters
+    ----------
+    items : list-like
+        Keep labels from axis which are in items.
+    like : str
+        Keep labels from axis for which "like in label == True".
+    regex : str (regular expression)
+        Keep labels from axis for which re.search(regex, label) == True.
+    axis : {0 or 'index', 1 or 'columns', None}, default None
+        The axis to filter on, expressed either as an index (int)
+        or axis name (str). By default this is the info axis, 'columns' for
+        DataFrame. For `Series` this parameter is unused and defaults to `None`.
+
+    Returns
+    -------
+    same type as input object
+
+    See Also
+    --------
+    DataFrame.loc : Access a group of rows and columns
+        by label(s) or a boolean array.
+
+    Notes
+    -----
+    The ``items``, ``like``, and ``regex`` parameters are
+    enforced to be mutually exclusive.
+
+    ``axis`` defaults to the info axis that is used when indexing
+    with ``[]``.
+
+    Examples
+    --------
+    >>> import maxframe.tensor as mt
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame(mt.array(([1, 2, 3], [4, 5, 6])),
+    ...                   index=['mouse', 'rabbit'],
+    ...                   columns=['one', 'two', 'three'])
+    >>> df.execute()
+            one  two  three
+    mouse     1    2      3
+    rabbit    4    5      6
+
+    >>> # select columns by name
+    >>> df.filter(items=['one', 'three']).execute()
+             one  three
+    mouse     1      3
+    rabbit    4      6
+
+    >>> # select columns by regular expression
+    >>> df.filter(regex='e$', axis=1).execute()
+             one  three
+    mouse     1      3
+    rabbit    4      6
+
+    >>> # select rows containing 'bbi'
+    >>> df.filter(like='bbi', axis=0).execute()
+             one  two  three
+    rabbit    4    5      6
+    """
+    if axis is None:
+        # For Series, axis is always 0 (index)
+        # For DataFrame, default is 1 (columns)
+        if hasattr(df_or_series, "columns"):
+            axis = 1  # DataFrame - filter columns by default
+        else:
+            axis = 0  # Series - filter index
+
+    param_count = sum(x is not None for x in [items, like, regex])
+    if param_count == 0:
+        raise TypeError("Must pass either `items`, `like`, or `regex`")
+    if param_count > 1:
+        raise TypeError(
+            "keyword arguments `items`, `like`, `regex` are mutually exclusive"
+        )
+    op = DataFrameFilter(items=items, like=like, regex=regex, axis=axis)
+    return op(df_or_series)

maxframe/dataframe/indexing/get_level_values.py

@@ -0,0 +1,76 @@
+# 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 ... import opcodes
+from ...serialization.serializables import AnyField
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+
+class IndexGetLevelValues(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.GET_LEVEL_VALUES
+
+    level = AnyField("level")
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    def __call__(self, index):
+        empty_index = index.index_value.to_pandas()
+        result_index = empty_index.get_level_values(self.level)
+
+        return self.new_index(
+            [index],
+            shape=(index.shape[0],),
+            dtype=result_index.dtype,
+            index_value=parse_index(result_index, store_data=False),
+            names=result_index.names,
+        )
+
+
+def get_level_values(index, level):
+    """
+    Return vector of label values for requested level.
+
+    Length of returned vector is equal to the length of the index.
+
+    Parameters
+    ----------
+    level : int or str
+        ``level`` is either the integer position of the level in the
+        MultiIndex, or the name of the level.
+
+    Returns
+    -------
+    values : Index
+        Values is a level of this MultiIndex converted to
+        a single :class:`Index` (or subclass thereof).
+
+    Examples
+    --------
+    Create a MultiIndex:
+
+    >>> import maxframe.dataframe as md
+    >>> import pandas as pd
+    >>> mi = md.Index(pd.MultiIndex.from_arrays((list('abc'), list('def')), names=['level_1', 'level_2']))
+
+    Get level values by supplying level as either integer or name:
+
+    >>> mi.get_level_values(0).execute()
+    Index(['a', 'b', 'c'], dtype='object', name='level_1')
+    >>> mi.get_level_values('level_2').execute()
+    Index(['d', 'e', 'f'], dtype='object', name='level_2')
+    """
+    op = IndexGetLevelValues(level=level)
+    return op(index)

maxframe/dataframe/indexing/iat.py

@@ -34,4 +34,49 @@ class DataFrameIat:
 
 
 def iat(a):
+    """
+    Access a single value for a row/column pair by integer position.
+
+    Similar to ``iloc``, in that both provide integer-based lookups. Use
+    ``iat`` if you only need to get or set a single value in a DataFrame
+    or Series.
+
+    Raises
+    ------
+    IndexError
+        When integer position is out of bounds.
+
+    See Also
+    --------
+    DataFrame.at : Access a single value for a row/column label pair.
+    DataFrame.loc : Access a group of rows and columns by label(s).
+    DataFrame.iloc : Access a group of rows and columns by integer position(s).
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> df = md.DataFrame([[0, 2, 3], [0, 4, 1], [10, 20, 30]],
+    ...                   columns=['A', 'B', 'C'])
+    >>> df.execute()
+        A   B   C
+    0   0   2   3
+    1   0   4   1
+    2  10  20  30
+
+    Get value at specified row/column pair
+
+    >>> df.iat[1, 2].execute()
+    1
+
+    Set value at specified row/column pair
+
+    >>> df.iat[1, 2] = 10
+    >>> df.iat[1, 2].execute()
+    10
+
+    Get value within a series
+
+    >>> df.loc[0].iat[1].execute()
+    2
+    """
     return DataFrameIat(a)

maxframe/dataframe/indexing/iloc.py

@@ -27,7 +27,7 @@ from ...serialization.serializables import AnyField, KeyField, ListField
 from ...tensor import asarray
 from ...tensor.indexing.core import calc_shape
 from ..operators import DATAFRAME_TYPE, DataFrameOperator, DataFrameOperatorMixin
-from ..utils import indexing_index_value
+from ..utils import indexing_index_value, validate_axis
 
 _ILOC_ERROR_MSG = (
     "Location based indexing can only have [integer, "
@@ -36,13 +36,16 @@ _ILOC_ERROR_MSG = (
 )
 
 
-def process_iloc_indexes(inp, indexes):
+def process_iloc_indexes(inp, indexes, axis=0):
     ndim = inp.ndim
 
     if not isinstance(indexes, tuple):
         indexes = (indexes,)
     if len(indexes) < ndim:
-        indexes += (slice(None),) * (ndim - len(indexes))
+        if not axis:
+            indexes += (slice(None),) * (ndim - len(indexes))
+        else:
+            indexes = (slice(None),) * (ndim - len(indexes)) + indexes
     if len(indexes) > ndim:
         raise IndexingError("Too many indexers")
 
@@ -105,32 +108,35 @@ def process_iloc_indexes(inp, indexes):
 
 
 class DataFrameIloc:
-    def __init__(self, obj):
+    def __init__(self, obj, axis=None):
         self._obj = obj
+        self._axis = axis
 
     def __getitem__(self, indexes):
+        indexes = process_iloc_indexes(self._obj, indexes, axis=self._axis)
         if isinstance(self._obj, DATAFRAME_TYPE):
-            op = DataFrameIlocGetItem(indexes=process_iloc_indexes(self._obj, indexes))
+            op = DataFrameIlocGetItem(indexes=indexes)
         else:
-            op = SeriesIlocGetItem(indexes=process_iloc_indexes(self._obj, indexes))
+            op = SeriesIlocGetItem(indexes=indexes)
         return op(self._obj)
 
     def __setitem__(self, indexes, value):
         if not np.isscalar(value):
             raise NotImplementedError("Only scalar value is supported to set by iloc")
 
+        indexes = process_iloc_indexes(self._obj, indexes, axis=self._axis)
         if isinstance(self._obj, DATAFRAME_TYPE):
-            op = DataFrameIlocSetItem(
-                indexes=process_iloc_indexes(self._obj, indexes), value=value
-            )
+            op = DataFrameIlocSetItem(indexes=indexes, value=value)
         else:
-            op = SeriesIlocSetItem(
-                indexes=process_iloc_indexes(self._obj, indexes), value=value
-            )
+            op = SeriesIlocSetItem(indexes=indexes, value=value)
 
         ret = op(self._obj)
         self._obj.data = ret.data
 
+    def __call__(self, axis):
+        axis = validate_axis(axis, self._obj)
+        return DataFrameIloc(self._obj, axis)
+
 
 class HeadTailOptimizedOperatorMixin(DataFrameOperatorMixin):
     __slots__ = ()
@@ -420,6 +426,140 @@ def index_setitem(_idx, *_):
 
 
 def iloc(a):
+    """
+    Purely integer-location based indexing for selection by position.
+
+    ``.iloc[]`` is primarily integer position based (from ``0`` to
+    ``length-1`` of the axis), but may also be used with a boolean
+    array.
+
+    Allowed inputs are:
+
+    - An integer, e.g. ``5``.
+    - A list or array of integers, e.g. ``[4, 3, 0]``.
+    - A slice object with ints, e.g. ``1:7``.
+    - A boolean array.
+    - A ``callable`` function with one argument (the calling Series or
+      DataFrame) and that returns valid output for indexing (one of the above).
+      This is useful in method chains, when you don't have a reference to the
+      calling object, but would like to base your selection on some value.
+
+    ``.iloc`` will raise ``IndexError`` if a requested indexer is
+    out-of-bounds, except *slice* indexers which allow out-of-bounds
+    indexing (this conforms with python/numpy *slice* semantics).
+
+    See more at :ref:`Selection by Position <indexing.integer>`.
+
+    See Also
+    --------
+    DataFrame.iat : Fast integer location scalar accessor.
+    DataFrame.loc : Purely label-location based indexer for selection by label.
+    Series.iloc : Purely integer-location based indexing for
+                   selection by position.
+
+    Examples
+    --------
+    >>> import maxframe.dataframe as md
+    >>> mydict = [{'a': 1, 'b': 2, 'c': 3, 'd': 4},
+    ...           {'a': 100, 'b': 200, 'c': 300, 'd': 400},
+    ...           {'a': 1000, 'b': 2000, 'c': 3000, 'd': 4000 }]
+    >>> df = md.DataFrame(mydict)
+    >>> df.execute()
+          a     b     c     d
+    0     1     2     3     4
+    1   100   200   300   400
+    2  1000  2000  3000  4000
+
+    **Indexing just the rows**
+
+    With a scalar integer.
+
+    >>> type(df.iloc[0]).execute()
+    <class 'pandas.core.series.Series'>
+    >>> df.iloc[0].execute()
+    a    1
+    b    2
+    c    3
+    d    4
+    Name: 0, dtype: int64
+
+    With a list of integers.
+
+    >>> df.iloc[[0]].execute()
+       a  b  c  d
+    0  1  2  3  4
+    >>> type(df.iloc[[0]]).execute()
+    <class 'pandas.core.frame.DataFrame'>
+
+    >>> df.iloc[[0, 1]].execute()
+         a    b    c    d
+    0    1    2    3    4
+    1  100  200  300  400
+
+    With a `slice` object.
+
+    >>> df.iloc[:3].execute()
+          a     b     c     d
+    0     1     2     3     4
+    1   100   200   300   400
+    2  1000  2000  3000  4000
+
+    With a boolean mask the same length as the index.
+
+    >>> df.iloc[[True, False, True]].execute()
+          a     b     c     d
+    0     1     2     3     4
+    2  1000  2000  3000  4000
+
+    With a callable, useful in method chains. The `x` passed
+    to the ``lambda`` is the DataFrame being sliced. This selects
+    the rows whose index label even.
+
+    >>> df.iloc[lambda x: x.index % 2 == 0].execute()
+          a     b     c     d
+    0     1     2     3     4
+    2  1000  2000  3000  4000
+
+    **Indexing both axes**
+
+    You can mix the indexer types for the index and columns. Use ``:`` to
+    select the entire axis.
+
+    With scalar integers.
+
+    >>> df.iloc[0, 1].execute()
+    2
+
+    With lists of integers.
+
+    >>> df.iloc[[0, 2], [1, 3]].execute()
+          b     d
+    0     2     4
+    2  2000  4000
+
+    With `slice` objects.
+
+    >>> df.iloc[1:3, 0:3].execute()
+          a     b     c
+    1   100   200   300
+    2  1000  2000  3000
+
+    With a boolean array whose length matches the columns.
+
+    >>> df.iloc[:, [True, False, True, False]].execute()
+          a     c
+    0     1     3
+    1   100   300
+    2  1000  3000
+
+    With a callable function that expects the Series or DataFrame.
+
+    >>> df.iloc[:, lambda df: [0, 2]].execute()
+          a     c
+    0     1     3
+    1   100   300
+    2  1000  3000
+    """
     return DataFrameIloc(a)
 
 

maxframe/dataframe/indexing/insert.py

@@ -17,10 +17,10 @@ from typing import List
 import pandas as pd
 
 from ... import opcodes
-from ...core import EntityData
+from ...core import EntityData, get_output_types
 from ...serialization.serializables import AnyField, BoolField, Int64Field
 from ...tensor.core import TENSOR_TYPE
-from ..core import SERIES_TYPE
+from ..core import INDEX_TYPE, SERIES_TYPE
 from ..operators import DataFrameOperator, DataFrameOperatorMixin
 from ..utils import build_empty_df, parse_index
 
@@ -29,17 +29,18 @@ class DataFrameInsert(DataFrameOperator, DataFrameOperatorMixin):
     _op_type_ = opcodes.INSERT
 
     loc = Int64Field("loc")
-    column = AnyField("column")
-    value = AnyField("value")
-    allow_duplicates = BoolField("allow_duplicates")
+    column = AnyField("column", default=None)
+    value = AnyField("value", default=None)
+    allow_duplicates = BoolField("allow_duplicates", default=False)
 
     @classmethod
     def _set_inputs(cls, op: "DataFrameInsert", inputs: List[EntityData]):
         super()._set_inputs(op, inputs)
         if len(inputs) > 1:
-            op._value = op._inputs[-1]
+            op.value = op._inputs[-1]
 
     def __call__(self, df):
+        self._output_types = get_output_types(df)
         inputs = [df]
         if isinstance(self.value, (SERIES_TYPE, TENSOR_TYPE)):
             value_dtype = self.value.dtype
@@ -47,19 +48,27 @@ class DataFrameInsert(DataFrameOperator, DataFrameOperatorMixin):
         else:
             value_dtype = pd.Series(self.value).dtype
 
-        empty_df = build_empty_df(df.dtypes)
-        empty_df.insert(
-            loc=self.loc,
-            column=self.column,
-            allow_duplicates=self.allow_duplicates,
-            value=pd.Series([], dtype=value_dtype),
-        )
-
         params = df.params
-        params["columns_value"] = parse_index(empty_df.columns, store_data=True)
-        params["dtypes"] = empty_df.dtypes
-        params["shape"] = (df.shape[0], df.shape[1] + 1)
-        return self.new_dataframe(inputs, **params)
+
+        if df.ndim == 2:
+            empty_obj = build_empty_df(df.dtypes)
+            empty_obj.insert(
+                loc=self.loc,
+                column=self.column,
+                allow_duplicates=self.allow_duplicates,
+                value=pd.Series([], dtype=value_dtype),
+            )
+
+            params["columns_value"] = parse_index(empty_obj.columns, store_data=True)
+            params["dtypes"] = empty_obj.dtypes
+            params["shape"] = (df.shape[0], df.shape[1] + 1)
+        else:
+            assert isinstance(df, INDEX_TYPE)
+            params["index_value"] = parse_index(
+                df.index_value, type(self), df, self.loc, self.value
+            )
+            params["shape"] = (df.shape[0] + 1,)
+        return self.new_tileable(inputs, **params)
 
 
 def df_insert(df, loc, column, value, allow_duplicates=False):
@@ -88,3 +97,22 @@ def df_insert(df, loc, column, value, allow_duplicates=False):
     )
     out_df = op(df)
     df.data = out_df.data
+
+
+def index_insert(idx, loc, value):
+    """
+    Make new Index inserting new item at location.
+
+    Follows Python list.append semantics for negative values.
+
+    Parameters
+    ----------
+    loc : int
+    item : object
+
+    Returns
+    -------
+    new_index : Index
+    """
+    op = DataFrameInsert(loc=loc, value=value)
+    return op(idx)