maxframe 1.3.1__cp39-cp39-win_amd64.whl → 2.0.0__cp39-cp39-win_amd64.whl

maxframe/lib/__init__.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/lib/compat.py

@@ -0,0 +1,145 @@
+from typing import TYPE_CHECKING, Callable, List, Sequence, Tuple, Union
+
+import numpy as np
+import pandas as pd
+
+if TYPE_CHECKING:
+    from pandas._typing import ArrayLike, Scalar
+
+
+def case_when(
+    self,
+    caselist: List[
+        Tuple[
+            Union[
+                "ArrayLike",
+                Callable[[pd.Series], Union[pd.Series, np.ndarray, Sequence[bool]]],
+            ],
+            Union[
+                "ArrayLike",
+                "Scalar",
+                Callable[[pd.Series], Union[pd.Series, np.ndarray]],
+            ],
+        ],
+    ],
+) -> pd.Series:
+    """
+    Replace values where the conditions are True.
+
+    Parameters
+    ----------
+    caselist : A list of tuples of conditions and expected replacements
+        Takes the form:  ``(condition0, replacement0)``,
+        ``(condition1, replacement1)``, ... .
+        ``condition`` should be a 1-D boolean array-like object
+        or a callable. If ``condition`` is a callable,
+        it is computed on the Series
+        and should return a boolean Series or array.
+        The callable must not change the input Series
+        (though pandas doesn`t check it). ``replacement`` should be a
+        1-D array-like object, a scalar or a callable.
+        If ``replacement`` is a callable, it is computed on the Series
+        and should return a scalar or Series. The callable
+        must not change the input Series
+        (though pandas doesn`t check it).
+
+        .. versionadded:: 2.2.0
+
+    Returns
+    -------
+    Series
+
+    See Also
+    --------
+    Series.mask : Replace values where the condition is True.
+
+    Examples
+    --------
+    >>> c = pd.Series([6, 7, 8, 9], name='c')
+    >>> a = pd.Series([0, 0, 1, 2])
+    >>> b = pd.Series([0, 3, 4, 5])
+
+    >>> c.case_when(caselist=[(a.gt(0), a),  # condition, replacement
+    ...                       (b.gt(0), b)])
+    0    6
+    1    3
+    2    1
+    3    2
+    Name: c, dtype: int64
+    """
+    from pandas.api.types import is_scalar
+    from pandas.core import common as com
+    from pandas.core.construction import array as pd_array
+    from pandas.core.dtypes.cast import (
+        construct_1d_arraylike_from_scalar,
+        find_common_type,
+        infer_dtype_from,
+    )
+    from pandas.core.dtypes.generic import ABCSeries
+
+    if not isinstance(caselist, list):
+        raise TypeError(
+            f"The caselist argument should be a list; instead got {type(caselist)}"
+        )
+
+    if not caselist:
+        raise ValueError(
+            "provide at least one boolean condition, "
+            "with a corresponding replacement."
+        )
+
+    for num, entry in enumerate(caselist):
+        if not isinstance(entry, tuple):
+            raise TypeError(
+                f"Argument {num} must be a tuple; instead got {type(entry)}."
+            )
+        if len(entry) != 2:
+            raise ValueError(
+                f"Argument {num} must have length 2; "
+                "a condition and replacement; "
+                f"instead got length {len(entry)}."
+            )
+    caselist = [
+        (
+            com.apply_if_callable(condition, self),
+            com.apply_if_callable(replacement, self),
+        )
+        for condition, replacement in caselist
+    ]
+    default = self.copy()
+    conditions, replacements = zip(*caselist)
+    common_dtypes = [infer_dtype_from(arg)[0] for arg in [*replacements, default]]
+    if len(set(common_dtypes)) > 1:
+        common_dtype = find_common_type(common_dtypes)
+        updated_replacements = []
+        for condition, replacement in zip(conditions, replacements):
+            if is_scalar(replacement):
+                replacement = construct_1d_arraylike_from_scalar(
+                    value=replacement, length=len(condition), dtype=common_dtype
+                )
+            elif isinstance(replacement, ABCSeries):
+                replacement = replacement.astype(common_dtype)
+            else:
+                replacement = pd_array(replacement, dtype=common_dtype)
+            updated_replacements.append(replacement)
+        replacements = updated_replacements
+        default = default.astype(common_dtype)
+
+    counter = reversed(range(len(conditions)))
+    for position, condition, replacement in zip(
+        counter, conditions[::-1], replacements[::-1]
+    ):
+        try:
+            default = default.mask(
+                condition, other=replacement, axis=0, inplace=False, level=None
+            )
+        except Exception as error:
+            raise ValueError(
+                f"Failed to apply condition{position} and replacement{position}."
+            ) from error
+    return default
+
+
+def patch_pandas():
+    if not hasattr(pd.Series, "case_when"):
+        pd.Series.case_when = case_when

maxframe/lib/filesystem/_oss_lib/glob.py

@@ -15,7 +15,7 @@
 """
 Filename globbing utility, modified from python glob.
 
-obviously，this implementation is not optimal, it will cause too many
+obviously, this implementation is not optimal, it will cause too many
 oss requests. Lately, We can then convert the glob expression into
 a regular expression, and then match the oss key list.
 But before that, we need to figure out how to deal with magic char

maxframe/lib/sparse/__init__.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -19,6 +17,7 @@ import operator
 from collections.abc import Iterable
 from functools import partial, reduce
 
+from . import linalg
 from .array import SparseNDArray, call_sparse
 from .core import get_sparse_module, issparse
 from .matrix import SparseMatrix
@@ -313,6 +312,12 @@ airy = partial(_call_unary, "airy")
 airye = partial(_call_unary, "airye")
 itairy = partial(_call_unary, "itairy")
 
+expit = partial(call_sparse, "expit")
+logit = partial(call_sparse, "logit")
+log_expit = partial(call_sparse, "log_expit")
+
+softplus = partial(call_sparse, "softplus")
+
 
 def equal(a, b, **_):
     try:
@@ -837,23 +842,13 @@ def tril(m, k=0, gpu=False):
     raise NotImplementedError
 
 
-def lu(m):
-    from .matrix import lu_sparse_matrix
-
-    return lu_sparse_matrix(m)
-
-
-def solve_triangular(a, b, lower=False, sparse=True):
-    from .matrix import solve_triangular_sparse_matrix
-
-    return solve_triangular_sparse_matrix(a, b, lower=lower, sparse=sparse)
-
-
 def block(arrs):
     arr = arrs[0]
     while isinstance(arr, list):
         arr = arr[0]
-    if arr.ndim != 2:  # pragma: no cover
+    if arr.ndim == 1:
+        return concatenate(arrs)
+    elif arr.ndim != 2:  # pragma: no cover
         raise NotImplementedError
 
     from .matrix import block

maxframe/lib/sparse/array.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -280,7 +278,7 @@ class SparseArray(SparseNDArray):
             return NotImplemented
         other_xp = get_array_module(naked_other)
         if other_xp.isscalar(naked_other):
-            return call_sparse("add", self, naked_other)
+            return other_xp.add(self.toarray(), naked_other)
         if issparse(naked_other):
             x = self.spmatrix + naked_other
         else:
@@ -296,7 +294,7 @@ class SparseArray(SparseNDArray):
             return NotImplemented
         other_xp = get_array_module(naked_other)
         if other_xp.isscalar(naked_other):
-            return call_sparse("add", naked_other, self)
+            return other_xp.add(naked_other, self.toarray())
         if issparse(naked_other):
             x = self.spmatrix + naked_other
         else:
@@ -312,7 +310,7 @@ class SparseArray(SparseNDArray):
             return NotImplemented
         other_xp = get_array_module(naked_other)
         if other_xp.isscalar(naked_other):
-            return call_sparse("subtract", self, naked_other)
+            return other_xp.subtract(self.toarray(), naked_other)
         if issparse(naked_other):
             x = self.spmatrix - naked_other
         else:
@@ -328,7 +326,7 @@ class SparseArray(SparseNDArray):
             return NotImplemented
         other_xp = get_array_module(naked_other)
         if other_xp.isscalar(naked_other):
-            return call_sparse("subtract", naked_other, self)
+            return other_xp.subtract(naked_other, self.toarray())
         if issparse(naked_other):
             x = naked_other - self.spmatrix
         else:
@@ -645,19 +643,24 @@ class SparseArray(SparseNDArray):
         return SparseNDArray(self.spmatrix.conj(), shape=self.shape)
 
     def exp(self):
-        return call_sparse("exp", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.exp(self.toarray())
 
     def exp2(self):
-        return call_sparse("exp2", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.exp2(self.toarray())
 
     def log(self):
-        return call_sparse("log", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.log(self.toarray())
 
     def log2(self):
-        return call_sparse("log2", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.log2(self.toarray())
 
     def log10(self):
-        return call_sparse("log10", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.log10(self.toarray())
 
     def expm1(self):
         return SparseNDArray(self.spmatrix.expm1(), shape=self.shape)
@@ -675,7 +678,8 @@ class SparseArray(SparseNDArray):
         return call_sparse("cbrt", self)
 
     def reciprocal(self):
-        return call_sparse("reciprocal", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.reciprocal(self.toarray())
 
     def _scipy_unary(self, func_name):
         spmatrix = self.spmatrix
@@ -952,7 +956,8 @@ class SparseArray(SparseNDArray):
         return get_array_module(x).asarray(x)
 
     def logical_not(self):
-        return call_sparse("logical_not", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.logical_not(self.toarray())
 
     @staticmethod
     def _bitwise(this, other, method_name):
@@ -989,23 +994,27 @@ class SparseArray(SparseNDArray):
         return self._bitwise(other, self.spmatrix, "bitwise_and")
 
     def __or__(self, other):
-        if get_array_module(other).isscalar(other):
-            return call_sparse("bitwise_or", self, other)
+        other_xp = get_array_module(other)
+        if other_xp.isscalar(other):
+            return other_xp.bitwise_or(self.toarray(), other)
         return self._bitwise(self.spmatrix, other, "bitwise_or")
 
     def __ror__(self, other):
-        if get_array_module(other).isscalar(other):
-            return call_sparse("bitwise_or", other, self)
+        other_xp = get_array_module(other)
+        if other_xp.isscalar(other):
+            return other_xp.bitwise_or(other, self.toarray())
         return self._bitwise(other, self.spmatrix, "bitwise_or")
 
     def __xor__(self, other):
-        if get_array_module(other).isscalar(other):
-            return call_sparse("bitwise_xor", self, other)
+        other_xp = get_array_module(other)
+        if other_xp.isscalar(other):
+            return other_xp.bitwise_xor(self.toarray(), other)
         return self._bitwise(self.spmatrix, other, "bitwise_xor")
 
     def __rxor__(self, other):
-        if get_array_module(other).isscalar(other):
-            return call_sparse("bitwise_xor", other, self)
+        other_xp = get_array_module(other)
+        if other_xp.isscalar(other):
+            return other_xp.bitwise_xor(other, self.toarray())
         return self._bitwise(other, self.spmatrix, "bitwise_xor")
 
     def isclose(self, other, **kw):
@@ -1020,7 +1029,8 @@ class SparseArray(SparseNDArray):
         return xp.isclose(self.toarray(), naked_other, **kw)
 
     def __invert__(self):
-        return call_sparse("invert", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.invert(self.toarray())
 
     @staticmethod
     def _shift(this, other, method_name):
@@ -1087,7 +1097,8 @@ class SparseArray(SparseNDArray):
         return SparseNDArray(self.spmatrix.sin(), shape=self.shape)
 
     def cos(self):
-        return call_sparse("cos", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.cos(self.toarray())
 
     def tan(self):
         return SparseNDArray(self.spmatrix.tan(), shape=self.shape)
@@ -1096,7 +1107,8 @@ class SparseArray(SparseNDArray):
         return SparseNDArray(self.spmatrix.arcsin(), shape=self.shape)
 
     def arccos(self):
-        return call_sparse("arccos", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.arccos(self.toarray())
 
     def arctan(self):
         return SparseNDArray(self.spmatrix.arctan(), shape=self.shape)
@@ -1145,7 +1157,8 @@ class SparseArray(SparseNDArray):
         return SparseNDArray(self.spmatrix.arcsinh(), shape=self.shape)
 
     def arccosh(self):
-        return call_sparse("arccosh", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.arccosh(self.toarray())
 
     def arctanh(self):
         return SparseNDArray(self.spmatrix.arctanh(), shape=self.shape)
@@ -1436,11 +1449,7 @@ class SparseArray(SparseNDArray):
 
     def i0(self):
         xp = get_array_module(self.spmatrix)
-        data = xp.i0(self.spmatrix.data).reshape(self.spmatrix.data.shape)
-        x = get_sparse_module(self.spmatrix).csr_matrix(
-            (data, self.spmatrix.indices, self.spmatrix.indptr), self.spmatrix.shape
-        )
-        return SparseNDArray(x, shape=self.shape)
+        return xp.i0(self.toarray())
 
     def nan_to_num(self):
         return call_sparse("nan_to_num", self)
@@ -1517,13 +1526,16 @@ class SparseArray(SparseNDArray):
         )
 
     def sinc(self):
-        return call_sparse("sinc", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.sinc(self.toarray())
 
     def isfinite(self):
-        return call_sparse("isfinite", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.isfinite(self.toarray())
 
     def isreal(self):
-        return call_sparse("isreal", self)
+        xp = get_array_module(self.spmatrix)
+        return xp.isreal(self.toarray())
 
     def digitize(self, bins, right=False):
         return call_sparse("digitize", self, bins=bins, right=right)

maxframe/lib/sparse/core.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/lib/sparse/linalg.py

@@ -0,0 +1,31 @@
+# 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 inv(m):
+    from .matrix import inv_sparse_matrix
+
+    return inv_sparse_matrix(m)
+
+
+def lu(m):
+    from .matrix import lu_sparse_matrix
+
+    return lu_sparse_matrix(m)
+
+
+def solve_triangular(a, b, lower=False, sparse=True):
+    from .matrix import solve_triangular_sparse_matrix
+
+    return solve_triangular_sparse_matrix(a, b, lower=lower, sparse=sparse)

maxframe/lib/sparse/matrix.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -113,6 +111,11 @@ def lu_sparse_matrix(a):
     )
 
 
+def inv_sparse_matrix(a):
+    a = naked(a)
+    return SparseMatrix(splinalg.inv(a))
+
+
 def solve_triangular_sparse_matrix(a, b, lower=False, sparse=True):
     a = naked(a)
     b = b.toarray() if issparse(b) else b

maxframe/lib/sparse/tests/__init__.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

maxframe/lib/sparse/tests/test_sparse.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -85,10 +83,8 @@ def test_sparse_add():
     assert_array_equal(s1 + s2, s1 + s2)
     assert_array_equal(s1 + d1, s1 + d1)
     assert_array_equal(d1 + s1, d1 + s1)
-    r = sps.csr_matrix(((s1.data + 1), s1.indices, s1.indptr), s1.shape)
-    assert_array_equal(s1 + 1, r)
-    r = sps.csr_matrix(((1 + s1.data), s1.indices, s1.indptr), s1.shape)
-    assert_array_equal(1 + s1, r)
+    assert_array_equal(s1 + 1, s1.toarray() + 1)
+    assert_array_equal(1 + s1.toarray(), 1 + s1.toarray())
 
     # test sparse vector
     v = SparseNDArray(v1, shape=(3,))
@@ -108,10 +104,8 @@ def test_sparse_subtract():
     assert_array_equal(s1 - s2, s1 - s2)
     assert_array_equal(s1 - d1, s1 - d1)
     assert_array_equal(d1 - s1, d1 - s1)
-    r = sps.csr_matrix(((s1.data - 1), s1.indices, s1.indptr), s1.shape)
-    assert_array_equal(s1 - 1, r)
-    r = sps.csr_matrix(((1 - s1.data), s1.indices, s1.indptr), s1.shape)
-    assert_array_equal(1 - s1, r)
+    assert_array_equal(s1 - 1, s1.toarray() - 1)
+    assert_array_equal(1 - s1, 1 - s1.toarray())
 
     # test sparse vector
     v = SparseNDArray(v1, shape=(3,))
@@ -264,53 +258,59 @@ def test_sparse_bin():
         assert_array_equal(lm(2, v), rm(2, v1_data))
 
 
-def test_sparse_unary():
+@pytest.mark.parametrize(
+    "method,dense",
+    [
+        ("exp", True),
+        ("exp2", True),
+        ("log", True),
+        ("log2", True),
+        ("log10", True),
+        ("reciprocal", True),
+        ("cos", True),
+        ("arccos", True),
+        ("arccosh", True),
+        ("sinc", True),
+        ("isreal", True),
+        ("isfinite", True),
+        ("negative", False),
+        ("positive", False),
+        ("absolute", False),
+        ("abs", False),
+        ("fabs", False),
+        ("rint", False),
+        ("sign", False),
+        ("conj", False),
+        ("expm1", False),
+        ("log1p", False),
+        ("sqrt", False),
+        ("square", False),
+        ("cbrt", False),
+        ("sin", False),
+        ("tan", False),
+        ("arcsin", False),
+        ("arctan", False),
+        ("arcsinh", False),
+        ("arctanh", False),
+        ("deg2rad", False),
+        ("rad2deg", False),
+        ("angle", False),
+        ("isnan", False),
+        ("isinf", False),
+        ("signbit", False),
+    ],
+)
+def test_sparse_unary_normal(method, dense):
     s1 = SparseNDArray(s1_data)
     v = SparseNDArray(v1, shape=(3,))
 
-    for method in (
-        "negative",
-        "positive",
-        "absolute",
-        "abs",
-        "fabs",
-        "rint",
-        "sign",
-        "conj",
-        "exp",
-        "exp2",
-        "log",
-        "log2",
-        "log10",
-        "expm1",
-        "log1p",
-        "sqrt",
-        "square",
-        "cbrt",
-        "reciprocal",
-        "sin",
-        "cos",
-        "tan",
-        "arcsin",
-        "arccos",
-        "arctan",
-        "arcsinh",
-        "arccosh",
-        "arctanh",
-        "deg2rad",
-        "rad2deg",
-        "angle",
-        "isnan",
-        "isinf",
-        "signbit",
-        "sinc",
-        "isreal",
-        "isfinite",
-    ):
-        lm, rm = getattr(mls, method), getattr(np, method)
+    lm, rm = getattr(mls, method), getattr(np, method)
+    if dense:
+        r = rm(s1.toarray())
+    else:
         r = sps.csr_matrix((rm(s1.data), s1.indices, s1.indptr), s1.shape)
-        assert_array_equal(lm(s1), r)
-        assert_array_equal(lm(v), rm(v1_data))
+    assert_array_equal(lm(s1), r)
+    assert_array_equal(lm(v), rm(v1_data))
 
 
 def test_sparse_dot():

maxframe/lib/sparse/vector.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 # Copyright 1999-2025 Alibaba Group Holding Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");