python-graphblas 2024.2.0__py3-none-any.whl → 2025.2.0a1__py3-none-any.whl

graphblas/core/base.py

@@ -513,7 +513,7 @@ class BaseType:
     _expect_op = _expect_op
 
     # Don't let non-scalars be coerced to numpy arrays
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, *, copy=None):
         raise TypeError(
             f"{type(self).__name__} can't be directly converted to a numpy array; "
             f"perhaps use `{self.name}.to_coo()` method instead."

graphblas/core/dtypes.py

@@ -1,4 +1,5 @@
 import warnings
+from ast import literal_eval
 
 import numpy as np
 from numpy import promote_types, result_type
@@ -97,7 +98,7 @@ def register_anonymous(dtype, name=None):
             # Allow dtypes such as `"INT64[3, 4]"` for convenience
             base_dtype, shape = dtype.split("[", 1)
             base_dtype = lookup_dtype(base_dtype)
-            shape = np.lib.format.safe_eval(f"[{shape}")
+            shape = literal_eval(f"[{shape}")
             dtype = np.dtype((base_dtype.np_type, shape))
         else:
             raise
@@ -115,7 +116,17 @@ def register_anonymous(dtype, name=None):
     from ..exceptions import check_status_carg
 
     gb_obj = ffi.new("GrB_Type*")
-    if backend == "suitesparse":
+
+    if hasattr(lib, "GrB_Type_set_String"):
+        # We name this so that we can serialize and deserialize UDTs
+        # We don't yet have C definitions
+        np_repr = _dtype_to_string(dtype)
+        status = lib.GrB_Type_new(gb_obj, dtype.itemsize)
+        check_status_carg(status, "Type", gb_obj[0])
+        val_obj = ffi.new("char[]", np_repr.encode())
+        status = lib.GrB_Type_set_String(gb_obj[0], val_obj, lib.GrB_NAME)
+    elif backend == "suitesparse":
+        # For SuiteSparse < 9
         # We name this so that we can serialize and deserialize UDTs
         # We don't yet have C definitions
         np_repr = _dtype_to_string(dtype).encode()
@@ -429,7 +440,7 @@ def _dtype_to_string(dtype):
         np_type = dtype.np_type
     s = str(np_type)
     try:
-        if np.dtype(np.lib.format.safe_eval(s)) == np_type:  # pragma: no branch (safety)
+        if np.dtype(literal_eval(s)) == np_type:  # pragma: no branch (safety)
             return s
     except Exception:
         pass
@@ -448,5 +459,5 @@ def _string_to_dtype(s):
         return lookup_dtype(s)
     except Exception:
         pass
-    np_type = np.dtype(np.lib.format.safe_eval(s))
+    np_type = np.dtype(literal_eval(s))
     return lookup_dtype(np_type)

graphblas/core/formatting.py

@@ -630,7 +630,7 @@ def create_header(type_name, keys, vals, *, lower_border=False, name="", quote=T
         name = f'"{name}"'
     key_text = []
     val_text = []
-    for key, val in zip(keys, vals):
+    for key, val in zip(keys, vals, strict=True):
         width = max(len(key), len(val)) + 2
         key_text.append(key.rjust(width))
         val_text.append(val.rjust(width))

graphblas/core/infix.py

@@ -316,6 +316,7 @@ class MatrixInfixExpr(InfixExprBase):
     ndim = 2
     output_type = MatrixExpression
     _is_transposed = False
+    __networkx_backend__ = "graphblas"
     __networkx_plugin__ = "graphblas"
 
     def __init__(self, left, right):

graphblas/core/matrix.py

@@ -184,6 +184,7 @@ class Matrix(BaseType):
     ndim = 2
     _is_transposed = False
     _name_counter = itertools.count()
+    __networkx_backend__ = "graphblas"
     __networkx_plugin__ = "graphblas"
 
     def __new__(cls, dtype=FP64, nrows=0, ncols=0, *, name=None):
@@ -360,7 +361,7 @@ class Matrix(BaseType):
     def __iter__(self):
         """Iterate over (row, col) indices which are present in the matrix."""
         rows, columns, _ = self.to_coo(values=False)
-        return zip(rows.flat, columns.flat)
+        return zip(rows.flat, columns.flat, strict=True)
 
     def __sizeof__(self):
         if backend == "suitesparse":
@@ -961,7 +962,7 @@ class Matrix(BaseType):
             rows = edgelist[:, 0]
             cols = edgelist[:, 1]
         else:
-            unzipped = list(zip(*edgelist))
+            unzipped = list(zip(*edgelist, strict=True))
             if len(unzipped) == 2:
                 rows, cols = unzipped
             elif len(unzipped) == 3:
@@ -1826,10 +1827,11 @@ class Matrix(BaseType):
         cols = cols.tolist()
         values = values.tolist()
         return {
-            row: dict(zip(cols[start:stop], values[start:stop]))
+            row: dict(zip(cols[start:stop], values[start:stop], strict=True))
             for row, (start, stop) in zip(
                 compressed_rows.tolist(),
                 np.lib.stride_tricks.sliding_window_view(indptr, 2).tolist(),
+                strict=True,
             )
         }
         # Alternative
@@ -3582,6 +3584,7 @@ class MatrixExpression(BaseExpression):
     ndim = 2
     output_type = Matrix
     _is_transposed = False
+    __networkx_backend__ = "graphblas"
     __networkx_plugin__ = "graphblas"
 
     def __init__(
@@ -3723,6 +3726,7 @@ class MatrixIndexExpr(AmbiguousAssignOrExtract):
     ndim = 2
     output_type = Matrix
     _is_transposed = False
+    __networkx_backend__ = "graphblas"
     __networkx_plugin__ = "graphblas"
 
     def __init__(self, parent, resolved_indexes, nrows, ncols):
@@ -3823,6 +3827,7 @@ class TransposedMatrix:
     ndim = 2
     _is_scalar = False
     _is_transposed = True
+    __networkx_backend__ = "graphblas"
     __networkx_plugin__ = "graphblas"
 
     def __init__(self, matrix):

graphblas/core/operator/base.py

@@ -251,8 +251,7 @@ class TypedOpBase:
 
     def __repr__(self):
         classname = self.opclass.lower()
-        if classname.endswith("op"):
-            classname = classname[:-2]
+        classname = classname.removesuffix("op")
         dtype2 = "" if self._type2 is None else f", {self._type2.name}"
         return f"{classname}.{self.name}[{self.type.name}{dtype2}]"
 

graphblas/core/scalar.py

@@ -165,7 +165,7 @@ class Scalar(BaseType):
             return self.__int__
         raise AttributeError("Scalar object only has `__index__` for integral dtypes")
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, *, copy=None):
         if dtype is None:
             dtype = self.dtype.np_type
         return np.array(self.value, dtype=dtype)

graphblas/core/ss/__init__.py

@@ -1,3 +1,5 @@
 import suitesparse_graphblas as _ssgb
 
-_IS_SSGB7 = _ssgb.__version__.split(".", 1)[0] == "7"
+(version_major, version_minor, version_bug) = map(int, _ssgb.__version__.split(".")[:3])
+
+_IS_SSGB7 = version_major == 7

graphblas/core/ss/config.py

@@ -99,7 +99,7 @@ class BaseConfig(MutableMapping):
                     return {reverse_bitwise[val]}
                 rv = set()
                 for k, v in self._bitwise[key].items():
-                    if isinstance(k, str) and val & v and bin(v).count("1") == 1:
+                    if isinstance(k, str) and val & v and (v).bit_count() == 1:
                         rv.add(k)
                 return rv
             if is_bool:

graphblas/core/ss/matrix.py

@@ -58,7 +58,7 @@ def head(matrix, n=10, dtype=None, *, sort=False):
         dtype = matrix.dtype
     else:
         dtype = lookup_dtype(dtype)
-    rows, cols, vals = zip(*itertools.islice(matrix.ss.iteritems(), n))
+    rows, cols, vals = zip(*itertools.islice(matrix.ss.iteritems(), n), strict=True)
     return np.array(rows, np.uint64), np.array(cols, np.uint64), np.array(vals, dtype.np_type)
 
 
@@ -3650,8 +3650,10 @@ class ss:
     def unpack_hyperhash(self, *, compute=False, name=None, **opts):
         """Unpacks the hyper_hash of a hypersparse matrix if possible.
 
-        Will return None if the matrix is not hypersparse or if the hash is not computed.
-        Use ``compute=True`` to compute the hyper_hash if the input is hypersparse.
+        Will return None if the matrix is not hypersparse, if the hash is not computed,
+        or if the hash is not needed. Use ``compute=True`` to try to compute the hyper_hash
+        if the input is hypersparse. The hyper_hash is optional in SuiteSparse:GraphBLAS,
+        so it may not be computed even with ``compute=True``.
 
         Use ``pack_hyperhash`` to move a hyper_hash matrix that was previously unpacked
         back into a matrix.
@@ -4079,6 +4081,21 @@ class ss:
         blob_handle = ffi_new("void**")
         blob_size_handle = ffi_new("GrB_Index*")
         parent = self._parent
+        if parent.dtype._is_udt and hasattr(lib, "GrB_Type_get_String"):
+            # Get the name from the dtype and set it to the name of the matrix so we can
+            # recreate the UDT. This is a bit hacky and we should restore the original name.
+            # First get the size of name.
+            dtype_size = ffi_new("size_t*")
+            status = lib.GrB_Type_get_SIZE(parent.dtype.gb_obj[0], dtype_size, lib.GrB_NAME)
+            check_status_carg(status, "Type", parent.dtype.gb_obj[0])
+            # Then get the name
+            dtype_char = ffi_new(f"char[{dtype_size[0]}]")
+            status = lib.GrB_Type_get_String(parent.dtype.gb_obj[0], dtype_char, lib.GrB_NAME)
+            check_status_carg(status, "Type", parent.dtype.gb_obj[0])
+            # Then set the name
+            status = lib.GrB_Matrix_set_String(parent._carg, dtype_char, lib.GrB_NAME)
+            check_status_carg(status, "Matrix", parent._carg)
+
         check_status(
             lib.GxB_Matrix_serialize(
                 blob_handle,
@@ -4120,8 +4137,8 @@ class ss:
         else:
             data = np.frombuffer(data, np.uint8)
         data_obj = ffi.from_buffer("void*", data)
-        # Get the dtype name first
         if dtype is None:
+            # Get the dtype name first (for non-UDTs)
             cname = ffi_new(f"char[{lib.GxB_MAX_NAME_LEN}]")
             info = lib.GxB_deserialize_type_name(
                 cname,
@@ -4131,6 +4148,22 @@ class ss:
             if info != lib.GrB_SUCCESS:
                 raise _error_code_lookup[info]("Matrix deserialize failed to get the dtype name")
             dtype_name = b"".join(itertools.takewhile(b"\x00".__ne__, cname)).decode()
+            if not dtype_name and hasattr(lib, "GxB_Serialized_get_String"):
+                # Handle UDTs. First get the size of name
+                dtype_size = ffi_new("size_t*")
+                info = lib.GxB_Serialized_get_SIZE(data_obj, dtype_size, lib.GrB_NAME, data.nbytes)
+                if info != lib.GrB_SUCCESS:
+                    raise _error_code_lookup[info](
+                        "Matrix deserialize failed to get the size of name"
+                    )
+                # Then get the name
+                dtype_char = ffi_new(f"char[{dtype_size[0]}]")
+                info = lib.GxB_Serialized_get_String(
+                    data_obj, dtype_char, lib.GrB_NAME, data.nbytes
+                )
+                if info != lib.GrB_SUCCESS:
+                    raise _error_code_lookup[info]("Matrix deserialize failed to get the name")
+                dtype_name = ffi.string(dtype_char).decode()
             dtype = _string_to_dtype(dtype_name)
         else:
             dtype = lookup_dtype(dtype)

graphblas/core/ss/vector.py

@@ -43,7 +43,7 @@ def head(vector, n=10, dtype=None, *, sort=False):
         dtype = vector.dtype
     else:
         dtype = lookup_dtype(dtype)
-    indices, vals = zip(*itertools.islice(vector.ss.iteritems(), n))
+    indices, vals = zip(*itertools.islice(vector.ss.iteritems(), n), strict=True)
     return np.array(indices, np.uint64), np.array(vals, dtype.np_type)
 
 
@@ -1652,6 +1652,21 @@ class ss:
         blob_handle = ffi_new("void**")
         blob_size_handle = ffi_new("GrB_Index*")
         parent = self._parent
+        if parent.dtype._is_udt and hasattr(lib, "GrB_Type_get_String"):
+            # Get the name from the dtype and set it to the name of the vector so we can
+            # recreate the UDT. This is a bit hacky and we should restore the original name.
+            # First get the size of name.
+            dtype_size = ffi_new("size_t*")
+            status = lib.GrB_Type_get_SIZE(parent.dtype.gb_obj[0], dtype_size, lib.GrB_NAME)
+            check_status_carg(status, "Type", parent.dtype.gb_obj[0])
+            # Then get the name
+            dtype_char = ffi_new(f"char[{dtype_size[0]}]")
+            status = lib.GrB_Type_get_String(parent.dtype.gb_obj[0], dtype_char, lib.GrB_NAME)
+            check_status_carg(status, "Type", parent.dtype.gb_obj[0])
+            # Then set the name
+            status = lib.GrB_Vector_set_String(parent._carg, dtype_char, lib.GrB_NAME)
+            check_status_carg(status, "Vector", parent._carg)
+
         check_status(
             lib.GxB_Vector_serialize(
                 blob_handle,
@@ -1694,7 +1709,7 @@ class ss:
             data = np.frombuffer(data, np.uint8)
         data_obj = ffi.from_buffer("void*", data)
         if dtype is None:
-            # Get the dtype name first
+            # Get the dtype name first (for non-UDTs)
             cname = ffi_new(f"char[{lib.GxB_MAX_NAME_LEN}]")
             info = lib.GxB_deserialize_type_name(
                 cname,
@@ -1704,6 +1719,22 @@ class ss:
             if info != lib.GrB_SUCCESS:
                 raise _error_code_lookup[info]("Vector deserialize failed to get the dtype name")
             dtype_name = b"".join(itertools.takewhile(b"\x00".__ne__, cname)).decode()
+            if not dtype_name and hasattr(lib, "GxB_Serialized_get_String"):
+                # Handle UDTs. First get the size of name
+                dtype_size = ffi_new("size_t*")
+                info = lib.GxB_Serialized_get_SIZE(data_obj, dtype_size, lib.GrB_NAME, data.nbytes)
+                if info != lib.GrB_SUCCESS:
+                    raise _error_code_lookup[info](
+                        "Vector deserialize failed to get the size of name"
+                    )
+                # Then get the name
+                dtype_char = ffi_new(f"char[{dtype_size[0]}]")
+                info = lib.GxB_Serialized_get_String(
+                    data_obj, dtype_char, lib.GrB_NAME, data.nbytes
+                )
+                if info != lib.GrB_SUCCESS:
+                    raise _error_code_lookup[info]("Vector deserialize failed to get the name")
+                dtype_name = ffi.string(dtype_char).decode()
             dtype = _string_to_dtype(dtype_name)
         else:
             dtype = lookup_dtype(dtype)

graphblas/core/utils.py

@@ -5,6 +5,8 @@ import numpy as np
 from ..dtypes import _INDEX, lookup_dtype
 from . import ffi, lib
 
+_NP2 = np.__version__.startswith("2.")
+
 
 def libget(name):
     """Helper to get items from GraphBLAS which might be GrB or GxB."""
@@ -60,7 +62,8 @@ def ints_to_numpy_buffer(array, dtype, *, name="array", copy=False, ownable=Fals
         and not np.issubdtype(array.dtype, np.bool_)
     ):
         raise ValueError(f"{name} must be integers, not {array.dtype.name}")
-    array = np.array(array, dtype, copy=copy, order=order)
+    # https://numpy.org/doc/stable/release/2.0.0-notes.html#new-copy-keyword-meaning-for-array-and-asarray-constructors
+    array = np.array(array, dtype, copy=copy or _NP2 and None, order=order)
     if ownable and (not array.flags.owndata or not array.flags.writeable):
         array = array.copy(order)
     return array
@@ -90,10 +93,14 @@ def values_to_numpy_buffer(
     """
     if dtype is not None:
         dtype = lookup_dtype(dtype)
-        array = np.array(array, _get_subdtype(dtype.np_type), copy=copy, order=order)
+        # https://numpy.org/doc/stable/release/2.0.0-notes.html#new-copy-keyword-meaning-for-array-and-asarray-constructors
+        array = np.array(
+            array, _get_subdtype(dtype.np_type), copy=copy or _NP2 and None, order=order
+        )
     else:
         is_input_np = isinstance(array, np.ndarray)
-        array = np.array(array, copy=copy, order=order)
+        # https://numpy.org/doc/stable/release/2.0.0-notes.html#new-copy-keyword-meaning-for-array-and-asarray-constructors
+        array = np.array(array, copy=copy or _NP2 and None, order=order)
         if array.dtype.hasobject:
             raise ValueError("object dtype for values is not allowed")
         if not is_input_np and array.dtype == np.int32:  # pragma: no cover
@@ -202,7 +209,7 @@ def normalize_chunks(chunks, shape):
             f"chunks argument must be of length {len(shape)} (one for each dimension of a {typ})"
         )
     chunksizes = []
-    for size, chunk in zip(shape, chunks):
+    for size, chunk in zip(shape, chunks, strict=True):
         if chunk is None:
             cur_chunks = [size]
         elif (c := maybe_integral(chunk)) is not None:
@@ -312,7 +319,10 @@ class _CArray:
         if size is not None:
             self.array = np.empty(size, dtype=dtype.np_type)
         else:
-            self.array = np.array(array, dtype=_get_subdtype(dtype.np_type), copy=False, order="C")
+            # https://numpy.org/doc/stable/release/2.0.0-notes.html#new-copy-keyword-meaning-for-array-and-asarray-constructors
+            self.array = np.array(
+                array, dtype=_get_subdtype(dtype.np_type), copy=_NP2 and None, order="C"
+            )
         c_type = dtype.c_type if dtype._is_udt else f"{dtype.c_type}*"
         self._carg = ffi.cast(c_type, ffi.from_buffer(self.array))
         self.dtype = dtype

graphblas/core/vector.py

@@ -772,7 +772,7 @@ class Vector(BaseType):
         """
         if isinstance(pairs, np.ndarray):
             raise TypeError("pairs as NumPy array is not supported; use `Vector.from_coo` instead")
-        unzipped = list(zip(*pairs))
+        unzipped = list(zip(*pairs, strict=True))
         if len(unzipped) == 2:
             indices, values = unzipped
         elif not unzipped:
@@ -2105,7 +2105,7 @@ class Vector(BaseType):
 
         """
         indices, values = self.to_coo(sort=False)
-        return dict(zip(indices.tolist(), values.tolist()))
+        return dict(zip(indices.tolist(), values.tolist(), strict=True))
 
 
 if backend == "suitesparse":

graphblas/exceptions.py

@@ -1,4 +1,3 @@
-from . import backend as _backend
 from .core import ffi as _ffi
 from .core import lib as _lib
 from .core.utils import _Pointer
@@ -85,9 +84,14 @@ class NotImplementedException(GraphblasException):
     """
 
 
+# SuiteSparse errors
+class JitError(GraphblasException):
+    """SuiteSparse:GraphBLAS error using JIT."""
+
+
 # Our errors
 class UdfParseError(GraphblasException):
-    """Unable to parse the user-defined function."""
+    """SuiteSparse:GraphBLAS unable to parse the user-defined function."""
 
 
 _error_code_lookup = {
@@ -112,8 +116,12 @@ _error_code_lookup = {
 }
 GrB_SUCCESS = _lib.GrB_SUCCESS
 GrB_NO_VALUE = _lib.GrB_NO_VALUE
-if _backend == "suitesparse":
+
+# SuiteSparse-specific errors
+if hasattr(_lib, "GxB_EXHAUSTED"):
     _error_code_lookup[_lib.GxB_EXHAUSTED] = StopIteration
+if hasattr(_lib, "GxB_JIT_ERROR"):  # Added in 9.4
+    _error_code_lookup[_lib.GxB_JIT_ERROR] = JitError
 
 
 def check_status(response_code, args):

graphblas/io/_networkx.py

@@ -55,7 +55,9 @@ def to_networkx(m, edge_attribute="weight"):
     cols = cols.tolist()
     G = nx.DiGraph()
     if edge_attribute is None:
-        G.add_edges_from(zip(rows, cols))
+        G.add_edges_from(zip(rows, cols, strict=True))
     else:
-        G.add_weighted_edges_from(zip(rows, cols, vals.tolist()), weight=edge_attribute)
+        G.add_weighted_edges_from(
+            zip(rows, cols, vals.tolist(), strict=True), weight=edge_attribute
+        )
     return G

graphblas/tests/conftest.py

@@ -3,6 +3,7 @@ import contextlib
 import functools
 import itertools
 import platform
+import sys
 from pathlib import Path
 
 import numpy as np
@@ -156,3 +157,10 @@ def compute(x):
 def shouldhave(module, opname):
     """Whether an "operator" module should have the given operator."""
     return supports_udfs or hasattr(module, opname)
+
+
+def dprint(*args, **kwargs):  # pragma: no cover (debug)
+    """Print to stderr for debugging purposes."""
+    kwargs["file"] = sys.stderr
+    kwargs["flush"] = True
+    print(*args, **kwargs)

graphblas/tests/test_dtype.py

@@ -224,6 +224,10 @@ def test_record_dtype_from_dict():
 def test_dtype_to_from_string():
     types = [dtypes.BOOL, dtypes.FP64]
     for c in string.ascii_letters:
+        if c == "T":
+            # See NEP 55 about StringDtype "T". Notably, this doesn't work:
+            # >>> np.dtype(np.dtype("T").str)
+            continue
         try:
             dtype = np.dtype(c)
             types.append(dtype)

graphblas/tests/test_io.py

@@ -146,7 +146,7 @@ def test_matrix_to_from_networkx():
     M = gb.io.from_networkx(G, nodelist=range(7))
     if suitesparse:
         assert M.ss.is_iso
-    rows, cols = zip(*edges)
+    rows, cols = zip(*edges, strict=True)
     expected = gb.Matrix.from_coo(rows, cols, 1)
     assert expected.isequal(M)
     # Test empty

graphblas/tests/test_matrix.py

@@ -2603,12 +2603,14 @@ def test_iter(A):
         zip(
             [3, 0, 3, 5, 6, 0, 6, 1, 6, 2, 4, 1],
             [0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6],
+            strict=True,
         )
     )
     assert set(A.T) == set(
         zip(
             [0, 1, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6],
             [3, 0, 3, 5, 6, 0, 6, 1, 6, 2, 4, 1],
+            strict=True,
         )
     )
 
@@ -2731,8 +2733,8 @@ def test_ss_split(A):
     for results in [A.ss.split([4, 3]), A.ss.split([[4, None], 3], name="split")]:
         row_boundaries = [0, 4, 7]
         col_boundaries = [0, 3, 6, 7]
-        for i, (i1, i2) in enumerate(zip(row_boundaries[:-1], row_boundaries[1:])):
-            for j, (j1, j2) in enumerate(zip(col_boundaries[:-1], col_boundaries[1:])):
+        for i, (i1, i2) in enumerate(itertools.pairwise(row_boundaries)):
+            for j, (j1, j2) in enumerate(itertools.pairwise(col_boundaries)):
                 expected = A[i1:i2, j1:j2].new()
                 assert expected.isequal(results[i][j])
     with pytest.raises(DimensionMismatch):
@@ -3068,7 +3070,7 @@ def test_ss_flatten(A):
         [3, 2, 3, 1, 5, 3, 7, 8, 3, 1, 7, 4],
     ]
     # row-wise
-    indices = [row * A.ncols + col for row, col in zip(data[0], data[1])]
+    indices = [row * A.ncols + col for row, col in zip(data[0], data[1], strict=True)]
     expected = Vector.from_coo(indices, data[2], size=A.nrows * A.ncols)
     for fmt in ["csr", "hypercsr", "bitmapr"]:
         B = Matrix.ss.import_any(**A.ss.export(format=fmt))
@@ -3087,7 +3089,7 @@ def test_ss_flatten(A):
     assert C.isequal(B)
 
     # column-wise
-    indices = [col * A.nrows + row for row, col in zip(data[0], data[1])]
+    indices = [col * A.nrows + row for row, col in zip(data[0], data[1], strict=True)]
     expected = Vector.from_coo(indices, data[2], size=A.nrows * A.ncols)
     for fmt in ["csc", "hypercsc", "bitmapc"]:
         B = Matrix.ss.import_any(**A.ss.export(format=fmt))
@@ -3626,9 +3628,9 @@ def test_ss_iteration(A):
     assert not list(B.ss.itervalues())
     assert not list(B.ss.iteritems())
     rows, columns, values = A.to_coo()
-    assert sorted(zip(rows, columns)) == sorted(A.ss.iterkeys())
+    assert sorted(zip(rows, columns, strict=True)) == sorted(A.ss.iterkeys())
     assert sorted(values) == sorted(A.ss.itervalues())
-    assert sorted(zip(rows, columns, values)) == sorted(A.ss.iteritems())
+    assert sorted(zip(rows, columns, values, strict=True)) == sorted(A.ss.iteritems())
     N = rows.size
 
     A = Matrix.ss.import_bitmapr(**A.ss.export("bitmapr"))
@@ -4072,10 +4074,11 @@ def test_ss_pack_hyperhash(A):
     Y = C.ss.unpack_hyperhash()
     Y = C.ss.unpack_hyperhash(compute=True)
     assert C.ss.unpack_hyperhash() is None
-    assert Y.nrows == C.nrows
-    C.ss.pack_hyperhash(Y)
-    assert Y.gb_obj[0] == gb.core.NULL
-    assert C.ss.unpack_hyperhash() is not None
+    if Y is not None:  # hyperhash may or may not be computed
+        assert Y.nrows == C.nrows
+        C.ss.pack_hyperhash(Y)
+        assert Y.gb_obj[0] == gb.core.NULL
+        assert C.ss.unpack_hyperhash() is not None  # May or may not be computed
 
 
 def test_to_dicts_from_dicts(A):

graphblas/tests/test_numpyops.py

@@ -5,6 +5,7 @@ import sys
 
 import numpy as np
 import pytest
+from packaging.version import parse
 
 import graphblas as gb
 import graphblas.binary.numpy as npbinary
@@ -112,6 +113,15 @@ def test_npunary():
                 match(accum=gb.binary.lor) << gb_result.apply(npunary.isnan)
             compare = match.reduce(gb.monoid.land).new()
             if not compare:  # pragma: no cover (debug)
+                import numba
+
+                if (
+                    unary_name in {"sign"}
+                    and np.__version__.startswith("2.")
+                    and parse(numba.__version__) < parse("0.61.0")
+                ):
+                    # numba <0.61.0 does not match numpy 2.0
+                    continue
                 print(unary_name, gb_input.dtype)
                 print(compute(gb_result))
                 print(np_result)

graphblas/tests/test_scalar.py

@@ -50,7 +50,7 @@ def test_dup(s):
     s_empty = Scalar(dtypes.FP64)
     s_unempty = Scalar.from_value(0.0)
     if s_empty.is_cscalar:
-        # NumPy wraps around
+        # NumPy <2 wraps around; >=2 raises OverflowError
         uint_data = [
             ("UINT8", 2**8 - 2),
             ("UINT16", 2**16 - 2),
@@ -73,6 +73,10 @@ def test_dup(s):
         ("FP32", -2.5),
         *uint_data,
     ]:
+        if dtype.startswith("UINT") and s_empty.is_cscalar and not np.__version__.startswith("1."):
+            with pytest.raises(OverflowError, match="out of bounds for uint"):
+                s4.dup(dtype=dtype, name="s5")
+            continue
         s5 = s4.dup(dtype=dtype, name="s5")
         assert s5.dtype == dtype
         assert s5.value == val

graphblas/tests/test_ssjit.py

@@ -1,6 +1,8 @@
 import os
 import pathlib
+import platform
 import sys
+import sysconfig
 
 import numpy as np
 import pytest
@@ -26,11 +28,48 @@ if backend != "suitesparse":
 
 @pytest.fixture(scope="module", autouse=True)
 def _setup_jit():
+    """Set up the SuiteSparse:GraphBLAS JIT."""
+    if _IS_SSGB7:
+        # SuiteSparse JIT was added in SSGB 8
+        yield
+        return
+
+    if not os.environ.get("GITHUB_ACTIONS"):
+        # Try to run the tests with defaults from sysconfig if not running in CI
+        prev = gb.ss.config["jit_c_control"]
+        cc = sysconfig.get_config_var("CC")
+        cflags = sysconfig.get_config_var("CFLAGS")
+        include = sysconfig.get_path("include")
+        libs = sysconfig.get_config_var("LIBS")
+        if not (cc is None or cflags is None or include is None or libs is None):
+            gb.ss.config["jit_c_control"] = "on"
+            gb.ss.config["jit_c_compiler_name"] = cc
+            gb.ss.config["jit_c_compiler_flags"] = f"{cflags} -I{include}"
+            gb.ss.config["jit_c_libraries"] = libs
+        else:
+            # Should we skip or try to run if sysconfig vars aren't set?
+            gb.ss.config["jit_c_control"] = "on"  # "off"
+        try:
+            yield
+        finally:
+            gb.ss.config["jit_c_control"] = prev
+        return
+
+    if (
+        sys.platform == "darwin"
+        or sys.platform == "linux"
+        and "conda" not in gb.ss.config["jit_c_compiler_name"]
+    ):
+        # XXX TODO: tests for SuiteSparse JIT are not passing on linux when using wheels or on osx
+        # This should be understood and fixed!
+        gb.ss.config["jit_c_control"] = "off"
+        yield
+        return
+
     # Configuration values below were obtained from the output of the JIT config
     # in CI, but with paths changed to use `{conda_prefix}` where appropriate.
-    if "CONDA_PREFIX" not in os.environ or _IS_SSGB7:
-        return
     conda_prefix = os.environ["CONDA_PREFIX"]
+    prev = gb.ss.config["jit_c_control"]
     gb.ss.config["jit_c_control"] = "on"
     if sys.platform == "linux":
         gb.ss.config["jit_c_compiler_name"] = f"{conda_prefix}/bin/x86_64-conda-linux-gnu-cc"
@@ -59,7 +98,7 @@ def _setup_jit():
         gb.ss.config["jit_c_compiler_flags"] = (
             "-march=core2 -mtune=haswell -mssse3 -ftree-vectorize -fPIC -fPIE "
             f"-fstack-protector-strong -O2 -pipe -isystem {conda_prefix}/include -DGBNCPUFEAT "
-            "-Wno-pointer-sign -O3 -DNDEBUG -fopenmp=libomp -fPIC -arch x86_64"
+            f"-Wno-pointer-sign -O3 -DNDEBUG -fopenmp=libomp -fPIC -arch {platform.machine()}"
         )
         gb.ss.config["jit_c_linker_flags"] = (
             "-Wl,-pie -Wl,-headerpad_max_install_names -Wl,-dead_strip_dylibs "
@@ -72,6 +111,7 @@ def _setup_jit():
             # This probably means we're testing a `python-suitesparse-graphblas` wheel
             # in a conda environment. This is not yet working.
             gb.ss.config["jit_c_control"] = "off"
+            yield
             return
 
         gb.ss.config["jit_c_compiler_name"] = f"{conda_prefix}/bin/cc"
@@ -86,6 +126,12 @@ def _setup_jit():
     if not pathlib.Path(gb.ss.config["jit_c_compiler_name"]).exists():
         # Can't use the JIT if we don't have a compiler!
         gb.ss.config["jit_c_control"] = "off"
+        yield
+        return
+    try:
+        yield
+    finally:
+        gb.ss.config["jit_c_control"] = prev
 
 
 @pytest.fixture

graphblas/tests/test_vector.py

@@ -29,6 +29,8 @@ from graphblas import Matrix, Scalar, Vector  # isort:skip (for dask-graphblas)
 
 
 suitesparse = backend == "suitesparse"
+if suitesparse:
+    ss_version_major = gb.core.ss.version_major
 
 
 @pytest.fixture
@@ -2205,7 +2207,10 @@ def test_udt():
 
     long_dtype = np.dtype([("x", np.bool_), ("y" * 1000, np.float64)], align=True)
     if suitesparse:
-        with pytest.warns(UserWarning, match="too large"):
+        if ss_version_major < 9:
+            with pytest.warns(UserWarning, match="too large"):
+                long_udt = dtypes.register_anonymous(long_dtype)
+        else:
             long_udt = dtypes.register_anonymous(long_dtype)
     else:
         # UDTs don't currently have a name in vanilla GraphBLAS
@@ -2216,13 +2221,19 @@ def test_udt():
     if suitesparse:
         vv = Vector.ss.deserialize(v.ss.serialize(), dtype=long_udt)
         assert v.isequal(vv, check_dtype=True)
-        with pytest.raises(SyntaxError):
-            # The size of the UDT name is limited
+        if ss_version_major < 9:
+            with pytest.raises(SyntaxError):
+                # The size of the UDT name is limited
+                Vector.ss.deserialize(v.ss.serialize())
+        else:
             Vector.ss.deserialize(v.ss.serialize())
     # May be able to look up non-anonymous dtypes by name if their names are too long
     named_long_dtype = np.dtype([("x", np.bool_), ("y" * 1000, np.float64)], align=False)
     if suitesparse:
-        with pytest.warns(UserWarning, match="too large"):
+        if ss_version_major < 9:
+            with pytest.warns(UserWarning, match="too large"):
+                named_long_udt = dtypes.register_new("LongUDT", named_long_dtype)
+        else:
             named_long_udt = dtypes.register_new("LongUDT", named_long_dtype)
     else:
         named_long_udt = dtypes.register_new("LongUDT", named_long_dtype)
@@ -2270,7 +2281,7 @@ def test_ss_iteration(v):
     # This is what I would expect
     assert sorted(indices) == sorted(v.ss.iterkeys())
     assert sorted(values) == sorted(v.ss.itervalues())
-    assert sorted(zip(indices, values)) == sorted(v.ss.iteritems())
+    assert sorted(zip(indices, values, strict=True)) == sorted(v.ss.iteritems())
 
     N = indices.size
     v = Vector.ss.import_bitmap(**v.ss.export("bitmap"))

{python_graphblas-2024.2.0.dist-info → python_graphblas-2025.2.0a1.dist-info}/METADATA

@@ -1,11 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: python-graphblas
-Version: 2024.2.0
+Version: 2025.2.0a1
 Summary: Python library for GraphBLAS: high-performance sparse linear algebra for scalable graph analytics
 Author: Jim Kitchen, Python-graphblas contributors
 Author-email: Erik Welch <erik.n.welch@gmail.com>
 Maintainer-email: Erik Welch <erik.n.welch@gmail.com>, Jim Kitchen <jim22k@gmail.com>, Sultan Orazbayev <contact@econpoint.com>
-License: Apache License
+License:                                  Apache License
                                    Version 2.0, January 2004
                                 https://www.apache.org/licenses/
         
@@ -219,10 +219,10 @@ Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Other Audience
@@ -231,52 +231,52 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
 Classifier: Topic :: Scientific/Engineering :: Mathematics
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy >=1.22
-Requires-Dist: donfig >=0.6
-Requires-Dist: pyyaml >=5.4
-Requires-Dist: suitesparse-graphblas <9,>=7.4.0.0
-Requires-Dist: numba >=0.55 ; python_version < "3.13"
-Provides-Extra: all
-Requires-Dist: python-graphblas[default,io,test,viz] ; extra == 'all'
-Requires-Dist: python-graphblas[datashade] ; (python_version < "3.13") and extra == 'all'
-Provides-Extra: datashade
-Requires-Dist: python-graphblas[numba,pandas,scipy] ; extra == 'datashade'
-Requires-Dist: datashader >=0.12 ; extra == 'datashade'
-Requires-Dist: hvplot >=0.7 ; extra == 'datashade'
-Provides-Extra: default
-Requires-Dist: python-graphblas[pandas,scipy,suitesparse] ; extra == 'default'
-Requires-Dist: python-graphblas[numba] ; (python_version < "3.13") and extra == 'default'
-Provides-Extra: io
-Requires-Dist: python-graphblas[networkx,scipy] ; extra == 'io'
-Requires-Dist: awkward >=1.9 ; extra == 'io'
-Requires-Dist: fast-matrix-market >=1.4.5 ; extra == 'io'
-Requires-Dist: python-graphblas[numba] ; (python_version < "3.13") and extra == 'io'
-Requires-Dist: sparse >=0.13 ; (python_version < "3.13") and extra == 'io'
+Requires-Dist: numpy>=1.23
+Requires-Dist: donfig>=0.6
+Requires-Dist: pyyaml>=5.4
+Requires-Dist: suitesparse-graphblas<10,>=7.4.0.0
+Requires-Dist: numba>=0.55; python_version < "3.14"
+Provides-Extra: suitesparse
+Requires-Dist: suitesparse-graphblas<10,>=7.4.0.0; extra == "suitesparse"
 Provides-Extra: networkx
-Requires-Dist: networkx >=2.8 ; extra == 'networkx'
+Requires-Dist: networkx>=2.8; extra == "networkx"
 Provides-Extra: numba
-Requires-Dist: numba >=0.55 ; extra == 'numba'
+Requires-Dist: numba>=0.55; extra == "numba"
 Provides-Extra: pandas
-Requires-Dist: pandas >=1.2 ; extra == 'pandas'
-Provides-Extra: repr
-Requires-Dist: python-graphblas[pandas] ; extra == 'repr'
+Requires-Dist: pandas>=1.5; extra == "pandas"
 Provides-Extra: scipy
-Requires-Dist: scipy >=1.9 ; extra == 'scipy'
-Provides-Extra: suitesparse
-Requires-Dist: suitesparse-graphblas <9,>=7.4.0.0 ; extra == 'suitesparse'
+Requires-Dist: scipy>=1.9; extra == "scipy"
 Provides-Extra: suitesparse-udf
-Requires-Dist: python-graphblas[numba,suitesparse] ; extra == 'suitesparse-udf'
-Provides-Extra: test
-Requires-Dist: python-graphblas[pandas,scipy,suitesparse] ; extra == 'test'
-Requires-Dist: packaging >=21 ; extra == 'test'
-Requires-Dist: pytest >=6.2 ; extra == 'test'
-Requires-Dist: tomli >=1 ; extra == 'test'
+Requires-Dist: python-graphblas[numba,suitesparse]; extra == "suitesparse-udf"
+Provides-Extra: repr
+Requires-Dist: python-graphblas[pandas]; extra == "repr"
+Provides-Extra: io
+Requires-Dist: python-graphblas[networkx,scipy]; extra == "io"
+Requires-Dist: python-graphblas[numba]; python_version < "3.14" and extra == "io"
+Requires-Dist: awkward>=2.0; extra == "io"
+Requires-Dist: sparse>=0.14; python_version < "3.13" and extra == "io"
+Requires-Dist: fast-matrix-market>=1.4.5; python_version < "3.13" and extra == "io"
 Provides-Extra: viz
-Requires-Dist: python-graphblas[networkx,scipy] ; extra == 'viz'
-Requires-Dist: matplotlib >=3.5 ; extra == 'viz'
+Requires-Dist: python-graphblas[networkx,scipy]; extra == "viz"
+Requires-Dist: matplotlib>=3.6; extra == "viz"
+Provides-Extra: datashade
+Requires-Dist: python-graphblas[numba,pandas,scipy]; extra == "datashade"
+Requires-Dist: datashader>=0.14; extra == "datashade"
+Requires-Dist: hvplot>=0.8; extra == "datashade"
+Provides-Extra: test
+Requires-Dist: python-graphblas[pandas,scipy,suitesparse]; extra == "test"
+Requires-Dist: packaging>=21; extra == "test"
+Requires-Dist: pytest>=6.2; extra == "test"
+Requires-Dist: tomli>=1; extra == "test"
+Provides-Extra: default
+Requires-Dist: python-graphblas[pandas,scipy,suitesparse]; extra == "default"
+Requires-Dist: python-graphblas[numba]; python_version < "3.14" and extra == "default"
+Provides-Extra: all
+Requires-Dist: python-graphblas[default,io,test,viz]; extra == "all"
+Requires-Dist: python-graphblas[datashade]; python_version < "3.14" and extra == "all"
 
 ![Python-graphblas](https://raw.githubusercontent.com/python-graphblas/python-graphblas/main/docs/_static/img/logo-horizontal-medium-big.svg)
 
@@ -315,14 +315,19 @@ For algorithms, see
 </p>
 
 ## Install
+
 Install the latest version of Python-graphblas via conda:
+
 ```
 $ conda install -c conda-forge python-graphblas
 ```
+
 or pip:
+
 ```
-$ pip install python-graphblas[default]
+$ pip install 'python-graphblas[default]'
 ```
+
 This will also install the [SuiteSparse:GraphBLAS](https://github.com/DrTimothyAldenDavis/GraphBLAS) compiled C library.
 We currently support the [GraphBLAS C API 2.0 specification](https://graphblas.org/docs/GraphBLAS_API_C_v2.0.0.pdf).
 
@@ -337,6 +342,7 @@ The following are not required by python-graphblas, but may be needed for certai
 - `fast-matrix-market` - for faster read/write of Matrix Market files with `gb.io.mmread` and `gb.io.mmwrite`.
 
 ## Description
+
 Currently works with [SuiteSparse:GraphBLAS](https://github.com/DrTimothyAldenDavis/GraphBLAS), but the goal is to make it work with all implementations of the GraphBLAS spec.
 
 The approach taken with this library is to follow the C-API 2.0 specification as closely as possible while making improvements
@@ -350,10 +356,12 @@ with how Python handles assignment, so instead we (ab)use the left-shift `<<` no
 assignment. This opens up all kinds of nice possibilities.
 
 This is an example of how the mapping works:
+
 ```C
 // C call
 GrB_Matrix_mxm(M, mask, GrB_PLUS_INT64, GrB_MIN_PLUS_INT64, A, B, NULL)
 ```
+
 ```python
 # Python call
 M(mask.V, accum=binary.plus) << A.mxm(B, semiring.min_plus)
@@ -371,10 +379,12 @@ is a much better approach, even if it doesn't feel very Pythonic.
 Descriptor flags are set on the appropriate elements to keep logic close to what it affects. Here is the same call
 with descriptor bits set. `ttcsr` indicates transpose the first and second matrices, complement the structure of the mask,
 and do a replacement on the output.
+
 ```C
 // C call
 GrB_Matrix_mxm(M, mask, GrB_PLUS_INT64, GrB_MIN_PLUS_INT64, A, B, desc.ttcsr)
 ```
+
 ```python
 # Python call
 M(~mask.S, accum=binary.plus, replace=True) << A.T.mxm(B.T, semiring.min_plus)
@@ -384,16 +394,20 @@ The objects receiving the flag operations (A.T, ~mask, etc) are also delayed obj
 do no computation, allowing the correct descriptor bits to be set in a single GraphBLAS call.
 
 **If no mask or accumulator is used, the call looks like this**:
+
 ```python
 M << A.mxm(B, semiring.min_plus)
 ```
+
 The use of `<<` to indicate updating is actually just syntactic sugar for a real `.update()` method. The above
 expression could be written as:
+
 ```python
 M.update(A.mxm(B, semiring.min_plus))
 ```
 
 ## Operations
+
 ```python
 M(mask, accum) << A.mxm(B, semiring)        # mxm
 w(mask, accum) << A.mxv(v, semiring)        # mxv
@@ -403,14 +417,18 @@ M(mask, accum) << A.ewise_mult(B, binaryop) # eWiseMult
 M(mask, accum) << A.kronecker(B, binaryop)  # kronecker
 M(mask, accum) << A.T                       # transpose
 ```
+
 ## Extract
+
 ```python
 M(mask, accum) << A[rows, cols]             # rows and cols are a list or a slice
 w(mask, accum) << A[rows, col_index]        # extract column
 w(mask, accum) << A[row_index, cols]        # extract row
 s = A[row_index, col_index].value           # extract single element
 ```
+
 ## Assign
+
 ```python
 M(mask, accum)[rows, cols] << A             # rows and cols are a list or a slice
 M(mask, accum)[rows, col_index] << v        # assign column
@@ -420,31 +438,42 @@ M[row_index, col_index] << s                # assign scalar to single element
                                             # (mask and accum not allowed)
 del M[row_index, col_index]                 # remove single element
 ```
+
 ## Apply
+
 ```python
 M(mask, accum) << A.apply(unaryop)
 M(mask, accum) << A.apply(binaryop, left=s)   # bind-first
 M(mask, accum) << A.apply(binaryop, right=s)  # bind-second
 ```
+
 ## Reduce
+
 ```python
 v(mask, accum) << A.reduce_rowwise(op)      # reduce row-wise
 v(mask, accum) << A.reduce_columnwise(op)   # reduce column-wise
 s(accum) << A.reduce_scalar(op)
 s(accum) << v.reduce(op)
 ```
+
 ## Creating new Vectors / Matrices
+
 ```python
 A = Matrix.new(dtype, num_rows, num_cols)   # new_type
 B = A.dup()                                 # dup
 A = Matrix.from_coo([row_indices], [col_indices], [values])  # build
 ```
+
 ## New from delayed
+
 Delayed objects can be used to create a new object using `.new()` method
+
 ```python
 C = A.mxm(B, semiring).new()
 ```
+
 ## Properties
+
 ```python
 size = v.size                               # size
 nrows = M.nrows                             # nrows
@@ -452,10 +481,13 @@ ncols = M.ncols                             # ncols
 nvals = M.nvals                             # nvals
 rindices, cindices, vals = M.to_coo()       # extractTuples
 ```
+
 ## Initialization
+
 There is a mechanism to initialize `graphblas` with a context prior to use. This allows for setting the backend to
 use as well as the blocking/non-blocking mode. If the context is not initialized, a default initialization will
 be performed automatically.
+
 ```python
 import graphblas as gb
 
@@ -466,10 +498,13 @@ gb.init("suitesparse", blocking=True)
 from graphblas import binary, semiring
 from graphblas import Matrix, Vector, Scalar
 ```
+
 ## Performant User Defined Functions
+
 Python-graphblas requires `numba` which enables compiling user-defined Python functions to native C for use in GraphBLAS.
 
 Example customized UnaryOp:
+
 ```python
 from graphblas import unary
 
@@ -484,9 +519,11 @@ v = Vector.from_coo([0, 1, 3], [1, 2, 3])
 w = v.apply(unary.force_odd).new()
 w  # indexes=[0, 1, 3], values=[1, 3, 3]
 ```
+
 Similar methods exist for BinaryOp, Monoid, and Semiring.
 
 ## Relation to other network analysis libraries
+
 Python-graphblas aims to provide an efficient and consistent expression
 of graph operations using linear algebra. This allows the development of
 high-performance implementations of existing and new graph algorithms
@@ -503,7 +540,9 @@ other libraries, `graphblas.io` contains multiple connectors, see the
 following section.
 
 ## Import/Export connectors to the Python ecosystem
+
 `graphblas.io` contains functions for converting to and from:
+
 ```python
 import graphblas as gb
 

{python_graphblas-2024.2.0.dist-info → python_graphblas-2025.2.0a1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 graphblas/__init__.py,sha256=hXLvBYOSgP210Z04K9hJ_k80zLJ1X7_u6HUpDJfZVRw,7131
-graphblas/exceptions.py,sha256=qF80UWYZ7GRvrSSFt3pKFglvISci3rn1QMg3zPefjfo,4272
+graphblas/exceptions.py,sha256=y_e_2erCA4o1DSBfKgyiYrh_1CagKmDLfXCP8wj-pw4,4509
 graphblas/graphblas.yaml,sha256=AuJWCjDwiUYuUYSwn3W5vbeqAenobqrM5HC081V28Ic,33
 graphblas/viz.py,sha256=5JVpiFsYNG9AetXKXX9Jh7T4OmbN-_JJ-GwVi9983As,7558
 graphblas/agg/__init__.py,sha256=fsFwEV5IOiP_a8w12X-NA-8Ltlhg81UFYOkc2UG_7Xg,3282
@@ -9,23 +9,23 @@ graphblas/binary/numpy.py,sha256=mxqRnWmzX9kofjvY-XhYvxkvMyojHPBOpi90MGPW7hE,537
 graphblas/binary/ss.py,sha256=7m-x5oihpD4CiNEf9aD3AQNGNu9T1XSL6ubU1iaVq7k,113
 graphblas/core/__init__.py,sha256=hgtNRdWJ5nC3zJo1vYE1L3oxXXBiTSWTtHTDPuQAyKQ,345
 graphblas/core/automethods.py,sha256=wJymJjfHQNWCZ-TePxXNJg71llhbMEhWOND2iASLDvI,12680
-graphblas/core/base.py,sha256=CWUHnMrcho6gEZThe3s_Zj9pOox7Vst6RabeKR7o52M,24496
+graphblas/core/base.py,sha256=FuLn2U6AadiMo5ZnAbEpxef67qFaF6zVVc3wxkcILug,24510
 graphblas/core/descriptor.py,sha256=dAdGs780GRK-a3lw_tI9u1sMhAP38LYoIxS_kZlezMQ,5979
-graphblas/core/dtypes.py,sha256=xgwlC035fyFNnbB7oCcAy_hiwooK_xbtKbgL7DPmWq8,13012
+graphblas/core/dtypes.py,sha256=Tob23pR5__jsJ9xqapd31KW0oB7AXp79u7mm6W83JUM,13478
 graphblas/core/expr.py,sha256=xf7XcdFWI_UEDGfLZZC31hLesb_dRwBIwJuASIrWVuQ,21154
-graphblas/core/formatting.py,sha256=lmD2hQULFhbh_8JVDi_tQTy9mWjR7Ah83dcd3AWfTxg,30152
-graphblas/core/infix.py,sha256=9RaSxkHyBM-0e71kCmCwQ99CSEwChYaIgAFCGas8luM,23038
+graphblas/core/formatting.py,sha256=o0HXpUfbivD04MGcNkn6wBH4p0DAUR7vd-4L0PxJ6JQ,30165
+graphblas/core/infix.py,sha256=g48IIhyaSHhk3pWyrdLJNNugjmJBUz4TO4cUSGmSrt4,23077
 graphblas/core/infixmethods.py,sha256=Ig36RjmHXW63uBWAqTa5QgpJcn4lV0u2V4S0zUdeXbo,11860
 graphblas/core/mask.py,sha256=aPC17q9fLH_VP2kfNYayetBU6tN-4Nx0HUKIT2fbBok,15877
-graphblas/core/matrix.py,sha256=-oUdeXd4MrtS9Hd5ICAqoUZoeYQ1u8HM6QHht3x7aVk,153043
+graphblas/core/matrix.py,sha256=GrW7fJZmTENX2UU3V027PQ-Ky9tV8n8qKrFB_1_PROc,153267
 graphblas/core/recorder.py,sha256=KJjVoS83LYDrRcqzc4zDL52m4rnuf-kTO5y2pQ_8qo8,5935
-graphblas/core/scalar.py,sha256=7er-mWsDwPjJncu67FFYEWScQ4Fp6cAzXeeBlZNOGC0,43034
+graphblas/core/scalar.py,sha256=QuBHl-0GdSPnUe3cBp84nw9gAbhn46c1vBys9tsnkNk,43048
 graphblas/core/slice.py,sha256=hmuEEdwdiXPYkyx67Ywqs1EBdYFyP_Jg7KFpZYc7vTA,1826
-graphblas/core/utils.py,sha256=OrVrI1-qvMQHZC1p_z2kLP9z0jFlvSBwTA3PHYfvR0A,13188
-graphblas/core/vector.py,sha256=1BVebkll8-mdZVkbj_DFZ0-aE8HeGVltwFOYXp4XVAc,86023
+graphblas/core/utils.py,sha256=uHBC1AlYf2Pp6OmXYVSgo6rdwp6d7d0uiPvdWopwTd0,13848
+graphblas/core/vector.py,sha256=ELHHA3cpwrHvPTwLgSSZlMwWCK3-djblL_3SUBjxRvA,86049
 graphblas/core/operator/__init__.py,sha256=uUTI1uat6ndA-qYpvbliyAt6arDTxXIVstDEdpmPyYo,743
 graphblas/core/operator/agg.py,sha256=aoUnd9oHK1QXi0dQ4lZZBpzijD2IAeTKa6h0EB6nEWU,24816
-graphblas/core/operator/base.py,sha256=eiM4jqrfQZqHQErZDsIIgkc9eV-HooW1R1-zgllZeeM,18160
+graphblas/core/operator/base.py,sha256=69SvKsP8L3TQZpCs67GB2xa_0lJww038hehBq2jt0qQ,18133
 graphblas/core/operator/binary.py,sha256=y0frqF0vmCdH5BP_JtVm6rKfVkCrwmlZn_dJz7antVI,36343
 graphblas/core/operator/indexunary.py,sha256=ZDOXra06AAyPRY_9XDHgxGfjldsXG6lYYHcX0Ccv_B8,19396
 graphblas/core/operator/monoid.py,sha256=1oQ2qQMENMoMD9WbyC3Q8b9lpRGDz_tgg-MYtDE7N4A,15893
@@ -33,18 +33,18 @@ graphblas/core/operator/select.py,sha256=CnOHQIBuI5ANgDqsnAFHiWnJVc8pKtesZNY2PEq
 graphblas/core/operator/semiring.py,sha256=aF4hv8G46gXgmgM_4w-6A3m935riTYvLP8vygnG2dsE,21708
 graphblas/core/operator/unary.py,sha256=Nrn-rSx4uZZ4OAJvrzsDkKTXRvFTNcGh_CyjLlW6iao,18340
 graphblas/core/operator/utils.py,sha256=WxxyqtlBg783-vLOWic4JPv0VpdzQ5Et42F_MaYjd6Q,15383
-graphblas/core/ss/__init__.py,sha256=TMqas3DedLi89UC_AENkdefnuUvi0B_395teuQl3zco,93
+graphblas/core/ss/__init__.py,sha256=546hNJvo_OeRrphaLMyJ18EmJrT_qGDiAF7AVnny65s,160
 graphblas/core/ss/binary.py,sha256=TDmFG5RIOO7sbSx2MpLnOuMlyBzel7Qcrd75uNUz-AU,4735
-graphblas/core/ss/config.py,sha256=QlDzYho7WkRt7yt0hFIyfj0zmTUj7vpOl7uO_rvoiHo,8278
+graphblas/core/ss/config.py,sha256=4DIkEl7_ETISlB6PY_GawjK-POwyjXcfUzi2IeoKea8,8276
 graphblas/core/ss/context.py,sha256=t2v9W1Lnwi4JJJp90tQxJjmdY4HDXSDhXU6DGE4aHHI,4620
 graphblas/core/ss/descriptor.py,sha256=0m4eyMbg355ev2mFPy53N9gVebBjYbRVXTbyxroxfoM,8304
 graphblas/core/ss/dtypes.py,sha256=QGRscMdb3WVygBXjLocW3k9XNN3WYr2qDKzVSnj3OvI,3583
 graphblas/core/ss/indexunary.py,sha256=G-GyCHZuTLInxcMCKiuOLY-pX4kfFIiwvo3dW8-j3jM,5941
-graphblas/core/ss/matrix.py,sha256=n8qsTBoPMBFy_4BNQgcpFj3V0YsledrQ4QXWe1MpAMI,150051
+graphblas/core/ss/matrix.py,sha256=k4ZomCKrSotNYwjkwyUZu30quC33WuXfeKFwcPas9NY,152100
 graphblas/core/ss/prefix_scan.py,sha256=JtxeKCQ4NNvhSgqmyaDVyMGdLEOgr3ARjNSBRfugsw4,5999
 graphblas/core/ss/select.py,sha256=QqgOQx3NemYYKgz8UWaaxix7syKLpHWxANqVs8z_cU4,3437
 graphblas/core/ss/unary.py,sha256=zuTYY3iHNhmA1yEPHO-Vt2yA6bM-KZppJj8nC_AVBR4,4036
-graphblas/core/ss/vector.py,sha256=Yd1N9M344wFADSuXyzx9T5CK0AUNnJykOWb53J-IJvI,59186
+graphblas/core/ss/vector.py,sha256=sEO3n7CRoeVprpXHR74kELv20eaZgsCNW8bPkMJ2eL4,61073
 graphblas/dtypes/__init__.py,sha256=veA5FgUQaBAoqyb3NPWJae3mP1dai2IeoLGI8nsyE10,943
 graphblas/dtypes/ss.py,sha256=_Xexm1SeoI3zr5AxSWUtWWTZC3Fg2AkZx82QK-4ZHDs,56
 graphblas/indexunary/__init__.py,sha256=PNubKaG9yiijl4sJJRcc7p4EFonUuk8y5Mqv10z3TyM,878
@@ -52,7 +52,7 @@ graphblas/indexunary/ss.py,sha256=FqVm91nMeOeU6sU3GaiGBTDTmjtABDjuO6Nl818_EZ8,11
 graphblas/io/__init__.py,sha256=YZHXdMGSc2cEmISECYrAaiNRKxupFaiCFhtgb2qvp-Y,253
 graphblas/io/_awkward.py,sha256=WCq3lwcH1L54qh79TykJlh-W3IkPLGr-zQElvL4ObUs,6598
 graphblas/io/_matrixmarket.py,sha256=qRJ3m87gifOaazgg0c35CyGQWHoTC_ZumLfGw-XKNSc,5484
-graphblas/io/_networkx.py,sha256=2ZI65KiWAxMgfWGO3DTRys3bb6FoVwnUaOm2Jteivds,1619
+graphblas/io/_networkx.py,sha256=w2dJXXTI1ZH6xCsL5wFYtwscrM5CZVK179k61BKGx98,1667
 graphblas/io/_scipy.py,sha256=JLELo8lDWH5eza0AdqyEuI4y60FlNTjKyZ4v9GZba24,4111
 graphblas/io/_sparse.py,sha256=7GQsn6-a5duO5G6uW0Nh-lNxaQL-rUU0dzvDUwsjqOw,3247
 graphblas/monoid/__init__.py,sha256=VF-uQiH7DXLoAIOcLOO0ftMy875nBXN1Tv5klnc7I4w,1076
@@ -69,7 +69,7 @@ graphblas/semiring/ss.py,sha256=_ZS0Iyx0O2oYoTOXza2SLjWNXeGBYuzKEvEljBIww4Y,57
 graphblas/ss/__init__.py,sha256=MRUECkNFgmY5BfMn7J5NE_N_oGZ5hCRETqOhzWsA2yo,235
 graphblas/ss/_core.py,sha256=i4XApSUWlSBmWvRxK3WJ29LKbooPPF3d7mRRvGfpjXo,12543
 graphblas/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-graphblas/tests/conftest.py,sha256=oXZLqUUD-pOy5iaQeQDDyTH1QWz_Sghq5t0WZWuNDto,4668
+graphblas/tests/conftest.py,sha256=BqQqTD9qjw7hU5IByRMsBlsipX-xWC7tWD_G4GeTELc,4874
 graphblas/tests/pickle1-vanilla.pkl,sha256=pJqNg_K-NtM8cmSGNcWJGGklFFAVYgJA0c8P8ofhenQ,2755
 graphblas/tests/pickle1.pkl,sha256=4E7TctG64NyxoyDawj6tawZolKyE_-T6zVp4RNgtPHQ,2998
 graphblas/tests/pickle2-vanilla.pkl,sha256=y62DcVUC0IBLeC8Xq_VAE6hL7gZIRKlJ20GOcJVFOBY,1453
@@ -79,29 +79,29 @@ graphblas/tests/pickle3.pkl,sha256=OOsg91sHvrZbp_LFmzufsZIaAIwdxq0QH6ZmprUbI2E,8
 graphblas/tests/test_auto_init.py,sha256=uCFe7KCk_rT_Hx2yKHaFm6yX1V00SnEdbXL5E5j80vY,506
 graphblas/tests/test_core.py,sha256=vZaVZfxogXYhk_9q77DwOmBcLMX4NM1ZM1F4LPdu6Q0,3278
 graphblas/tests/test_descriptor.py,sha256=H-ZClw8ZNSb22V446MR3kdHeGGvpGeF24g3FLTuch0g,579
-graphblas/tests/test_dtype.py,sha256=Z13JMeiTDGgakpLUEPXk5J0Gsq9ee-TBh_Xbk88nTUs,8715
+graphblas/tests/test_dtype.py,sha256=bbFgJIdBtQvuYaOtQjwkZcqmnQx1Z-5cjQ27LcVw4bw,8879
 graphblas/tests/test_external_init.py,sha256=AqtKhi9w-gdkerMa_MEYH4Av1gV-dFdy_840Z7Ka1Do,302
 graphblas/tests/test_formatting.py,sha256=HaIzQJU9FUSJxlYOb61Z1Lp5Mm84UPJ3C7ErEojdAoE,187980
 graphblas/tests/test_infix.py,sha256=n3ltg07DIlqT7sUNubUHxC2EBSPkYb9RJtn-t65qvoo,29058
-graphblas/tests/test_io.py,sha256=_HQEqXdvKacN_Ql3IoOSA8LnCL2OhOTKaJCZk7RBjq4,17241
+graphblas/tests/test_io.py,sha256=t_iYWAM8EJEYvpmpJe-ljMg-UtlMOle-l4yigBAqAHo,17254
 graphblas/tests/test_mask.py,sha256=LYYy46dzzJlOMLAU5zZ2Yivony8wFxAESTkiL9RJLKM,4693
-graphblas/tests/test_matrix.py,sha256=eqh7Dy2nG-3NuBwidmeRRFRNS-xl8AEAHaftlyvOR2s,157367
-graphblas/tests/test_numpyops.py,sha256=67dLqyv32Of5EsPdesBae4w26jHLq_tnKHdcbwyB8UE,13296
+graphblas/tests/test_matrix.py,sha256=mYshUu2OHV61xXhA7iVrOHSlcqU8WwiS7h5_XaVZUBo,157557
+graphblas/tests/test_numpyops.py,sha256=by3MVs5NtONLNSkAqghyyK1KCMz82jDaNas5UfOmejk,13658
 graphblas/tests/test_op.py,sha256=SX-actrjLqEcGSdlf-y8bFonLhYo93rAAgMisqUnu8g,55332
 graphblas/tests/test_operator_types.py,sha256=JJY8BlHmyK8GVzyPf1eirBfahGMJ12wP_a1e40ZEqvU,11007
 graphblas/tests/test_pickle.py,sha256=uzFH9WzpdYbYy1pN_a7oGX-mZS2QvU2fF-Tta6FDKDQ,12735
 graphblas/tests/test_prefix_scan.py,sha256=nvwIywIDj6earTyZ6QLwpcWEZNssQebuV5P1XlSbyHw,2476
 graphblas/tests/test_recorder.py,sha256=YcqGt99PpV2iBYtOEQlwh_rWOY0CHp44e21IqRiiAA8,9199
 graphblas/tests/test_resolving.py,sha256=oQDCjTc2dimLavAJ7JeaEsQ1UH_ezsbigQq4zLAm3RQ,10923
-graphblas/tests/test_scalar.py,sha256=XEYUE1wdu4n2Yi3E9wB1sB2wzmgUtGtjqQO30ix9tos,19471
+graphblas/tests/test_scalar.py,sha256=x4-9-ptNA9E1rubqQSMNL5OWoVgihhFwb0Ff3yoO-w0,19747
 graphblas/tests/test_ss_utils.py,sha256=8-GYG7ITeXYcsU0qbOof_5dosKZaXiVt3fsgzFLKKJs,10985
-graphblas/tests/test_ssjit.py,sha256=IRjrNqzbc8XylX1MqoaH7D9MrH-Q5SNA6Sqk-QAn5mA,16194
-graphblas/tests/test_vector.py,sha256=WAHb26vXQSecGovu3PQZlHMRlwJJn8kcJ79cvY6rCsg,89881
+graphblas/tests/test_ssjit.py,sha256=P6HCsWXJfl7Krh0M8ieyK3G2DM8zSUHSxyjPzHHdJDw,17784
+graphblas/tests/test_vector.py,sha256=ZU4g1vV5PEChVkLaOZED5hlabVolxStbzpjjc_J0zs8,90318
 graphblas/unary/__init__.py,sha256=PT-rSt4DfhPR7Go7HG6qc5CsXOy7I3XNq8M91e9ugrQ,1561
 graphblas/unary/numpy.py,sha256=nnuoHrOlOftovU_gQHQKH-oNO87uD6i23QseYNNqL8o,4158
 graphblas/unary/ss.py,sha256=0cetCBuSFKSE8Wt9JjduIP02581q83tg_tUJ4MrzC4I,112
-python_graphblas-2024.2.0.dist-info/LICENSE,sha256=tc3W3NZiv6HV_-4e16TQoM-zm7fohpX2t283tjKC_hg,11368
-python_graphblas-2024.2.0.dist-info/METADATA,sha256=CtSsgEEKM67Xp8fR9CoKiPUVlAjJLsumETxuVltyYjs,29547
-python_graphblas-2024.2.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-python_graphblas-2024.2.0.dist-info/top_level.txt,sha256=QC8r4KyBl_LkZYZUdrsd0-NAJuQQcD_2fwGGiX104OM,10
-python_graphblas-2024.2.0.dist-info/RECORD,,
+python_graphblas-2025.2.0a1.dist-info/LICENSE,sha256=tc3W3NZiv6HV_-4e16TQoM-zm7fohpX2t283tjKC_hg,11368
+python_graphblas-2025.2.0a1.dist-info/METADATA,sha256=gWZldzcL_xz0wv7WvorToTIxEAU3p26fqX4nBi41oqw,29602
+python_graphblas-2025.2.0a1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+python_graphblas-2025.2.0a1.dist-info/top_level.txt,sha256=QC8r4KyBl_LkZYZUdrsd0-NAJuQQcD_2fwGGiX104OM,10
+python_graphblas-2025.2.0a1.dist-info/RECORD,,

{python_graphblas-2024.2.0.dist-info → python_graphblas-2025.2.0a1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any