maxframe 2.0.0b2__cp311-cp311-win32.whl → 2.2.0__cp311-cp311-win32.whl

maxframe/dataframe/arithmetic/dot.py

@@ -0,0 +1,237 @@
+# 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 typing import List
+
+import numpy as np
+import pandas as pd
+
+from ... import opcodes
+from ...core import EntityData
+from ...serialization.serializables import AnyField, KeyField
+from ...tensor import tensor as astensor
+from ...tensor.core import TENSOR_TYPE
+from ..core import DATAFRAME_TYPE, SERIES_TYPE
+from ..operators import DataFrameOperator, DataFrameOperatorMixin
+from ..utils import parse_index
+
+
+class DataFrameDot(DataFrameOperator, DataFrameOperatorMixin):
+    _op_type_ = opcodes.DOT
+
+    lhs = KeyField("lhs")
+    rhs = AnyField("rhs")
+
+    def __init__(self, output_types=None, **kw):
+        super().__init__(_output_types=output_types, **kw)
+
+    @classmethod
+    def _set_inputs(cls, op: "DataFrameDot", inputs: List[EntityData]):
+        super()._set_inputs(op, inputs)
+        op.lhs, op.rhs = op._inputs[:2]
+
+    def __call__(self, lhs, rhs):
+        lhs = self._process_input(lhs)
+        rhs = self._process_input(rhs)
+        if not isinstance(rhs, (DATAFRAME_TYPE, SERIES_TYPE)):
+            rhs = astensor(rhs)
+            test_rhs = rhs
+        else:
+            test_rhs = rhs.to_tensor()
+
+        test_ret = lhs.to_tensor().dot(test_rhs)
+        if test_ret.ndim == 0:
+            if isinstance(lhs, SERIES_TYPE) and isinstance(rhs, TENSOR_TYPE):
+                # return tensor
+                return test_ret
+            return self.new_scalar([lhs, rhs], dtype=test_ret.dtype)
+        elif test_ret.ndim == 1:
+            if lhs.ndim == 1:
+                if hasattr(rhs, "columns_value"):
+                    index_value = rhs.columns_value
+                else:
+                    # tensor
+                    length = -1 if np.isnan(rhs.shape[1]) else rhs.shape[1]
+                    pd_index = pd.RangeIndex(length)
+                    index_value = parse_index(pd_index, store_data=True)
+            else:
+                assert rhs.ndim == 1
+                index_value = lhs.index_value
+            return self.new_series(
+                [lhs, rhs],
+                shape=test_ret.shape,
+                dtype=test_ret.dtype,
+                index_value=index_value,
+            )
+        else:
+            if isinstance(rhs, TENSOR_TYPE):
+                dtypes = pd.Series(
+                    np.repeat(test_ret.dtype, test_ret.shape[1]),
+                    index=pd.RangeIndex(test_ret.shape[1]),
+                )
+                columns_value = parse_index(dtypes.index, store_data=True)
+            else:
+                dtypes = pd.Series(
+                    np.repeat(test_ret.dtype, test_ret.shape[1]),
+                    index=rhs.columns_value.to_pandas(),
+                )
+                columns_value = rhs.columns_value
+            return self.new_dataframe(
+                [lhs, rhs],
+                shape=test_ret.shape,
+                index_value=lhs.index_value,
+                columns_value=columns_value,
+                dtypes=dtypes,
+            )
+
+
+def dot(df_or_series, other):
+    op = DataFrameDot(lhs=df_or_series, rhs=other)
+    return op(df_or_series, other)
+
+
+def rdot(df_or_series, other):
+    op = DataFrameDot(lhs=other, rhs=df_or_series)
+    return op(other, df_or_series)
+
+
+dot.__frame_doc__ = """
+Compute the matrix multiplication between the DataFrame and other.
+
+This method computes the matrix product between the DataFrame and the
+values of an other Series, DataFrame or a numpy array.
+
+It can also be called using ``self @ other`` in Python >= 3.5.
+
+Parameters
+----------
+other : Series, DataFrame or array-like
+    The other object to compute the matrix product with.
+
+Returns
+-------
+Series or DataFrame
+    If other is a Series, return the matrix product between self and
+    other as a Series. If other is a DataFrame or a numpy.array, return
+    the matrix product of self and other in a DataFrame of a np.array.
+
+See Also
+--------
+Series.dot: Similar method for Series.
+
+Notes
+-----
+The dimensions of DataFrame and other must be compatible in order to
+compute the matrix multiplication. In addition, the column names of
+DataFrame and the index of other must contain the same values, as they
+will be aligned prior to the multiplication.
+
+The dot method for Series computes the inner product, instead of the
+matrix product here.
+
+Examples
+--------
+Here we multiply a DataFrame with a Series.
+
+>>> import maxframe.tensor as mt
+>>> import maxframe.dataframe as md
+>>> df = md.DataFrame([[0, 1, -2, -1], [1, 1, 1, 1]])
+>>> s = md.Series([1, 1, 2, 1])
+>>> df.dot(s).execute()
+0    -4
+1     5
+dtype: int64
+
+Here we multiply a DataFrame with another DataFrame.
+
+>>> other = md.DataFrame([[0, 1], [1, 2], [-1, -1], [2, 0]])
+>>> df.dot(other).execute()
+    0   1
+0   1   4
+1   2   2
+
+Note that the dot method give the same result as @
+
+>>> (df @ other).execute()
+    0   1
+0   1   4
+1   2   2
+
+The dot method works also if other is an np.array.
+
+>>> arr = mt.array([[0, 1], [1, 2], [-1, -1], [2, 0]])
+>>> df.dot(arr).execute()
+    0   1
+0   1   4
+1   2   2
+
+Note how shuffling of the objects does not change the result.
+
+>>> s2 = s.reindex([1, 0, 2, 3])
+>>> df.dot(s2).execute()
+0    -4
+1     5
+dtype: int64
+"""
+dot.__series_doc__ = """
+Compute the dot product between the Series and the columns of other.
+
+This method computes the dot product between the Series and another
+one, or the Series and each columns of a DataFrame, or the Series and
+each columns of an array.
+
+It can also be called using `self @ other` in Python >= 3.5.
+
+Parameters
+----------
+other : Series, DataFrame or array-like
+    The other object to compute the dot product with its columns.
+
+Returns
+-------
+scalar, Series or numpy.ndarray
+    Return the dot product of the Series and other if other is a
+    Series, the Series of the dot product of Series and each rows of
+    other if other is a DataFrame or a numpy.ndarray between the Series
+    and each columns of the numpy array.
+
+See Also
+--------
+DataFrame.dot: Compute the matrix product with the DataFrame.
+Series.mul: Multiplication of series and other, element-wise.
+
+Notes
+-----
+The Series and other has to share the same index if other is a Series
+or a DataFrame.
+
+Examples
+--------
+>>> import maxframe.tensor as mt
+>>> import maxframe.dataframe as md
+>>> s = md.Series([0, 1, 2, 3])
+>>> other = md.Series([-1, 2, -3, 4])
+>>> s.dot(other).execute()
+8
+>>> (s @ other).execute()
+8
+>>> df = md.DataFrame([[0, 1], [-2, 3], [4, -5], [6, 7]])
+>>> s.dot(df).execute()
+0    24
+1    14
+dtype: int64
+>>> arr = mt.array([[0, 1], [-2, 3], [4, -5], [6, 7]])
+>>> s.dot(arr).execute()
+array([24, 14])
+"""

maxframe/dataframe/arithmetic/{around.py → round.py}

@@ -18,9 +18,10 @@ from ...utils import classproperty
 from .core import DataFrameUnaryUfunc
 
 
-class DataFrameAround(DataFrameUnaryUfunc):
+class DataFrameRound(DataFrameUnaryUfunc):
     _op_type_ = opcodes.AROUND
-    _func_name = "around"
+    _func_name = "round"
+    _legacy_name = "DataFrameAround"  # since v2.3.0
 
     decimals = Int32Field("decimals", default=None)
 
@@ -34,17 +35,20 @@ class DataFrameAround(DataFrameUnaryUfunc):
         return TensorAround
 
 
-def around(df, decimals=0, *args, **kwargs):
+def round(df, decimals=0, *args, **kwargs):
     if len(args) > 0:
         raise TypeError(
             f"round() takes 0 positional arguments but {len(args)} was given"
         )
-    op = DataFrameAround(decimals=decimals, **kwargs)
+    op = DataFrameRound(decimals=decimals, **kwargs)
     return op(df)
 
 
-# FIXME Series input of decimals not supported yet
-around.__frame_doc__ = """
+# keep for import compatibility
+DataFrameAround = DataFrameRound
+
+
+round.__frame_doc__ = """
 Round a DataFrame to a variable number of decimal places.
 
 Parameters
@@ -108,7 +112,7 @@ places as value
 2   0.7   0.0
 3   0.2   0.0
 """
-around.__series_doc__ = """
+round.__series_doc__ = """
 Round each value in a Series to the given number of decimals.
 
 Parameters

maxframe/dataframe/core.py

@@ -56,8 +56,11 @@ from ..utils import (
     ceildiv,
     estimate_pandas_size,
     on_serialize_numpy_type,
+    pd_release_version,
+    prevent_called_from_pandas,
     tokenize,
 )
+from .typing_ import DataFrameType, IndexType, SeriesType
 from .utils import (
     ReprSeries,
     apply_if_callable,
@@ -66,6 +69,8 @@ from .utils import (
     parse_index,
 )
 
+_df_with_iteritems = pd_release_version[:2] < (2, 0)
+
 
 class IndexValue(Serializable):
     """
@@ -478,9 +483,17 @@ _lazy_chunk_meta_properties = (
 )
 
 
+def _calc_cum_nsplit(nsplit: Tuple[int]) -> List[int]:
+    return [0] + np.cumsum(nsplit).tolist()
+
+
+def calc_cum_nsplits(nsplits: Tuple[Tuple[int]]) -> List[List[int]]:
+    return tuple(_calc_cum_nsplit(nsplit) for nsplit in nsplits)
+
+
 @functools.lru_cache(maxsize=128)
 def _get_cum_nsplit(nsplit: Tuple[int]) -> List[int]:
-    return [0] + np.cumsum(nsplit).tolist()
+    return _calc_cum_nsplit(nsplit)
 
 
 def _calc_axis_slice(nsplit: Tuple[int], index: int) -> slice:
@@ -684,6 +697,10 @@ class IndexData(HasShapeTileableData, _ToPandasMixin):
     def names(self):
         return getattr(self, "_names", None) or [self.name]
 
+    @property
+    def nlevels(self) -> int:
+        return len(self.names)
+
     @property
     def index_value(self) -> IndexValue:
         return self._index_value
@@ -818,6 +835,9 @@ class Index(HasShapeTileable, _ToPandasMixin):
     def __len__(self):
         return len(self._data)
 
+    def __class_getitem__(cls, item):
+        return IndexType.from_getitem_args(item)
+
     def __maxframe_tensor__(self, dtype=None, order="K"):
         return self._data.__maxframe_tensor__(dtype=dtype, order=order)
 
@@ -1049,12 +1069,6 @@ class BaseSeriesData(HasShapeTileableData, _ToPandasMixin):
 
         return from_series(self, dtype=dtype)
 
-    @staticmethod
-    def from_tensor(in_tensor, index=None, name=None):
-        from .datasource.from_tensor import series_from_tensor
-
-        return series_from_tensor(in_tensor, index=index, name=name)
-
 
 class SeriesData(_BatchedFetcher, BaseSeriesData):
     type_name = "Series"
@@ -1065,8 +1079,9 @@ class SeriesData(_BatchedFetcher, BaseSeriesData):
         return tensor.astype(dtype=dtype, order=order, copy=False)
 
     def iteritems(self, batch_size=10000, session=None):
+        method_name = "iteritems" if _df_with_iteritems else "items"
         for batch_data in self.iterbatch(batch_size=batch_size, session=session):
-            yield from getattr(batch_data, "iteritems")()
+            yield from getattr(batch_data, method_name)()
 
     items = iteritems
 
@@ -1082,12 +1097,39 @@ class SeriesData(_BatchedFetcher, BaseSeriesData):
         name = name or self.name or 0
         return dataframe_from_tensor(self, columns=[name])
 
+    @property
+    def hasnans(self):
+        """
+        Return True if there are any NaNs.
+
+        Returns
+        -------
+        bool
+
+        Examples
+        --------
+        >>> import maxframe.dataframe as md
+        >>> s = md.Series([1, 2, 3, None])
+        >>> s.execute()
+        0    1.0
+        1    2.0
+        2    3.0
+        3    NaN
+        dtype: float64
+        >>> s.hasnans.execute()
+        True
+        """
+        return self.isna().any()
+
 
 class Series(HasShapeTileable, _ToPandasMixin):
     __slots__ = ("_cache",)
     _allow_data_type_ = (SeriesData,)
     type_name = "Series"
 
+    def __class_getitem__(cls, item):
+        return SeriesType.from_getitem_args(item)
+
     def to_tensor(self, dtype=None):
         return self._data.to_tensor(dtype=dtype)
 
@@ -1185,6 +1227,11 @@ class Series(HasShapeTileable, _ToPandasMixin):
         else:
             return super()._view()
 
+    def __iter__(self):
+        # prevent being called by pandas to make sure `__eq__` works
+        prevent_called_from_pandas()
+        return (tp[1] for tp in self.items())
+
     def __len__(self):
         return len(self._data)
 
@@ -1297,98 +1344,6 @@ class Series(HasShapeTileable, _ToPandasMixin):
         """
         return self._data.to_frame(name=name)
 
-    def between(self, left, right, inclusive="both"):
-        """
-        Return boolean Series equivalent to left <= series <= right.
-        This function returns a boolean vector containing `True` wherever the
-        corresponding Series element is between the boundary values `left` and
-        `right`. NA values are treated as `False`.
-
-        Parameters
-        ----------
-        left : scalar or list-like
-            Left boundary.
-        right : scalar or list-like
-            Right boundary.
-        inclusive : {"both", "neither", "left", "right"}
-            Include boundaries. Whether to set each bound as closed or open.
-
-        Returns
-        -------
-        Series
-            Series representing whether each element is between left and
-            right (inclusive).
-
-        See Also
-        --------
-        Series.gt : Greater than of series and other.
-        Series.lt : Less than of series and other.
-
-        Notes
-        -----
-        This function is equivalent to ``(left <= ser) & (ser <= right)``
-
-        Examples
-        --------
-        >>> import maxframe.dataframe as md
-        >>> s = md.Series([2, 0, 4, 8, np.nan])
-
-        Boundary values are included by default:
-
-        >>> s.between(1, 4).execute()
-        0     True
-        1    False
-        2     True
-        3    False
-        4    False
-        dtype: bool
-
-        With `inclusive` set to ``"neither"`` boundary values are excluded:
-
-        >>> s.between(1, 4, inclusive="neither").execute()
-        0     True
-        1    False
-        2    False
-        3    False
-        4    False
-        dtype: bool
-
-        `left` and `right` can be any scalar value:
-
-        >>> s = md.Series(['Alice', 'Bob', 'Carol', 'Eve'])
-        >>> s.between('Anna', 'Daniel').execute()
-        0    False
-        1     True
-        2     True
-        3    False
-        dtype: bool
-        """
-        if isinstance(inclusive, bool):  # pragma: no cover
-            # for pandas < 1.3.0
-            if inclusive:
-                inclusive = "both"
-            else:
-                inclusive = "neither"
-        if inclusive == "both":
-            lmask = self >= left
-            rmask = self <= right
-        elif inclusive == "left":
-            lmask = self >= left
-            rmask = self < right
-        elif inclusive == "right":
-            lmask = self > left
-            rmask = self <= right
-        elif inclusive == "neither":
-            lmask = self > left
-            rmask = self < right
-        else:
-            raise ValueError(
-                "Inclusive has to be either string of 'both',"
-                "'left', 'right', or 'neither'."
-            )
-
-        return lmask & rmask
-
     # def median(
     #     self, axis=None, skipna=True, out=None, overwrite_input=False, keepdims=False
     # ):
@@ -1589,18 +1544,6 @@ class BaseDataFrameData(HasShapeTileableData, _ToPandasMixin):
 
         return from_dataframe(self, dtype=dtype)
 
-    @staticmethod
-    def from_tensor(in_tensor, index=None, columns=None):
-        from .datasource.from_tensor import dataframe_from_tensor
-
-        return dataframe_from_tensor(in_tensor, index=index, columns=columns)
-
-    @staticmethod
-    def from_records(records, **kw):
-        from .datasource.from_records import from_records
-
-        return from_records(records, **kw)
-
     @property
     def index(self):
         from .datasource.index import from_tileable
@@ -1747,12 +1690,6 @@ class DataFrame(HasShapeTileable, _ToPandasMixin):
     def to_tensor(self):
         return self._data.to_tensor()
 
-    def from_tensor(self, in_tensor, index=None, columns=None):
-        return self._data.from_tensor(in_tensor, index=index, columns=columns)
-
-    def from_records(self, records, **kw):
-        return self._data.from_records(records, **kw)
-
     def __maxframe_tensor__(self, dtype=None, order="K"):
         return self._data.__maxframe_tensor__(dtype=dtype, order=order)
 
@@ -1772,6 +1709,14 @@ class DataFrame(HasShapeTileable, _ToPandasMixin):
             + [k for k in self.dtypes.index if isinstance(k, str) and k.isidentifier()]
         )
 
+    def __iter__(self):
+        # prevent being called by pandas to make sure `__eq__` works
+        prevent_called_from_pandas()
+        return iter(self.dtypes.index)
+
+    def __class_getitem__(cls, item):
+        return DataFrameType.from_getitem_args(item)
+
     @property
     def T(self):
         return self.transpose()

maxframe/dataframe/datasource/__init__.py

@@ -13,3 +13,21 @@
 # limitations under the License.
 
 from .core import PandasDataSourceOperator
+from .from_dict import dataframe_from_dict
+from .from_records import from_records
+from .from_tensor import dataframe_from_tensor, series_from_tensor
+
+
+def _install():
+    from ..core import DATAFRAME_TYPE, SERIES_TYPE
+
+    for t in DATAFRAME_TYPE:
+        t.from_dict = staticmethod(dataframe_from_dict)
+        t.from_records = staticmethod(from_records)
+        t.from_tensor = staticmethod(dataframe_from_tensor)
+    for t in SERIES_TYPE:
+        t.from_tensor = staticmethod(series_from_tensor)
+
+
+_install()
+del _install

maxframe/dataframe/datasource/from_dict.py

@@ -0,0 +1,124 @@
+# 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 ...core import ENTITY_TYPE
+from ...utils import find_objects, no_default
+from ..utils import validate_axis
+
+
+def dataframe_from_dict(data, orient="columns", dtype=None, columns=None):
+    """
+    Construct DataFrame from dict of array-like or dicts.
+
+    Creates DataFrame object from dictionary by columns or by index
+    allowing dtype specification.
+
+    Parameters
+    ----------
+    data : dict
+        Of the form {field : array-like} or {field : dict}.
+    orient : {'columns', 'index', 'tight'}, default 'columns'
+        The "orientation" of the data. If the keys of the passed dict
+        should be the columns of the resulting DataFrame, pass 'columns'
+        (default). Otherwise if the keys should be rows, pass 'index'.
+        If 'tight', assume a dict with keys ['index', 'columns', 'data',
+        'index_names', 'column_names'].
+
+    dtype : dtype, default None
+        Data type to force after DataFrame construction, otherwise infer.
+    columns : list, default None
+        Column labels to use when ``orient='index'``. Raises a ValueError
+        if used with ``orient='columns'`` or ``orient='tight'``.
+
+    Returns
+    -------
+    DataFrame
+
+    See Also
+    --------
+    DataFrame.from_records : DataFrame from structured ndarray, sequence
+        of tuples or dicts, or DataFrame.
+    DataFrame : DataFrame object creation using constructor.
+    DataFrame.to_dict : Convert the DataFrame to a dictionary.
+
+    Examples
+    --------
+    By default the keys of the dict become the DataFrame columns:
+
+    >>> import maxframe.dataframe as md
+    >>> data = {'col_1': [3, 2, 1, 0], 'col_2': ['a', 'b', 'c', 'd']}
+    >>> md.DataFrame.from_dict(data).execute()
+       col_1 col_2
+    0      3     a
+    1      2     b
+    2      1     c
+    3      0     d
+
+    Specify ``orient='index'`` to create the DataFrame using dictionary
+    keys as rows:
+
+    >>> data = {'row_1': [3, 2, 1, 0], 'row_2': ['a', 'b', 'c', 'd']}
+    >>> md.DataFrame.from_dict(data, orient='index').execute()
+           0  1  2  3
+    row_1  3  2  1  0
+    row_2  a  b  c  d
+
+    When using the 'index' orientation, the column names can be
+    specified manually:
+
+    >>> md.DataFrame.from_dict(data, orient='index',
+    ...                        columns=['A', 'B', 'C', 'D']).execute()
+           A  B  C  D
+    row_1  3  2  1  0
+    row_2  a  b  c  d
+
+    Specify ``orient='tight'`` to create the DataFrame using a 'tight'
+    format:
+
+    >>> data = {'index': [('a', 'b'), ('a', 'c')],
+    ...         'columns': [('x', 1), ('y', 2)],
+    ...         'data': [[1, 3], [2, 4]],
+    ...         'index_names': ['n1', 'n2'],
+    ...         'column_names': ['z1', 'z2']}
+    >>> md.DataFrame.from_dict(data, orient='tight').execute()
+    z1     x  y
+    z2     1  2
+    n1 n2
+    a  b   1  3
+       c   2  4
+    """
+    from ..initializer import DataFrame as DataFrameInit
+    from .from_tensor import dataframe_from_1d_tileables
+
+    if orient != "tight" and not find_objects(data, ENTITY_TYPE):
+        res = DataFrameInit(data)
+    elif orient == "tight":
+        # init directly
+        init_kw = {
+            "index": data.get("index"),
+            "columns": data.get("columns"),
+        }
+        df = DataFrameInit(data["data"], **init_kw)
+        rename_kw = {
+            "index": data.get("index_names", no_default),
+            "columns": data.get("column_names", no_default),
+        }
+        res = df.rename_axis(**rename_kw)
+    else:
+        axis = validate_axis(orient)
+        res = dataframe_from_1d_tileables(data, columns=columns, axis=axis)
+
+    if dtype is not None:
+        res = res.astype(dtype)
+    return res