python-graphblas 2023.12.0__tar.gz → 2025.2.0__tar.gz

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: python-graphblas
-Version: 2023.12.0
+Version: 2025.2.0
 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>
@@ -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,22 +231,22 @@ 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.21
+Requires-Dist: numpy>=1.23
 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.12"
+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<9,>=7.4.0.0; extra == "suitesparse"
+Requires-Dist: suitesparse-graphblas<10,>=7.4.0.0; extra == "suitesparse"
 Provides-Extra: networkx
 Requires-Dist: networkx>=2.8; extra == "networkx"
 Provides-Extra: numba
 Requires-Dist: numba>=0.55; extra == "numba"
 Provides-Extra: pandas
-Requires-Dist: pandas>=1.2; extra == "pandas"
+Requires-Dist: pandas>=1.5; extra == "pandas"
 Provides-Extra: scipy
 Requires-Dist: scipy>=1.9; extra == "scipy"
 Provides-Extra: suitesparse-udf
@@ -255,17 +255,17 @@ 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.12" and extra == "io"
-Requires-Dist: awkward>=1.9; extra == "io"
-Requires-Dist: sparse>=0.13; python_version < "3.12" and extra == "io"
-Requires-Dist: fast-matrix-market>=1.4.5; 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: matplotlib>=3.6; extra == "viz"
 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"
+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"
@@ -273,10 +273,10 @@ 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.12" and 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.12" and 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-2023.12.0 → python_graphblas-2025.2.0}/README.md

@@ -35,14 +35,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).
 
@@ -57,6 +62,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
@@ -70,10 +76,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)
@@ -91,10 +99,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)
@@ -104,16 +114,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
@@ -123,14 +137,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
@@ -140,31 +158,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
@@ -172,10 +201,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
 
@@ -186,10 +218,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
 
@@ -204,9 +239,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
@@ -223,7 +260,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-2023.12.0 → python_graphblas-2025.2.0}/graphblas/agg/__init__.py

@@ -73,7 +73,8 @@ Custom recipes (specific to SuiteSparse:GraphBLAS):
 #   - bxnor monoid: even bits
 #   - bnor monoid: odd bits
 """
-# All items are dynamically added by classes in core/agg.py
+
+# All items are dynamically added by classes in core/operator/agg.py
 # This module acts as a container of Aggregator instances
 _deprecated = {}
 

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/graphblas/binary/numpy.py

@@ -5,6 +5,7 @@ See list of numpy ufuncs supported by numpy here:
 https://numba.readthedocs.io/en/stable/reference/numpysupported.html#math-operations
 
 """
+
 import numpy as _np
 
 from .. import _STANDARD_OPERATOR_NAMES

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/graphblas/core/automethods.py

@@ -7,6 +7,7 @@ To automatically create the functions, run:
 $ python -m graphblas.core.automethods
 
 """
+
 from .. import config
 
 
@@ -281,10 +282,6 @@ def to_edgelist(self):
     return self._get_value("to_edgelist")
 
 
-def to_values(self):
-    return self._get_value("to_values")
-
-
 def value(self):
     return self._get_value("value")
 
@@ -398,7 +395,6 @@ def _main():
         "ss",
         "to_coo",
         "to_dense",
-        "to_values",
     }
     vector = {
         "_as_matrix",

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/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."

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/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()
@@ -375,8 +386,7 @@ def lookup_dtype(key, value=None):
 
 
 def unify(type1, type2, *, is_left_scalar=False, is_right_scalar=False):
-    """
-    Returns a type that can hold both type1 and type2.
+    """Returns a type that can hold both type1 and type2.
 
     For example:
     unify(INT32, INT64) -> INT64
@@ -430,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
@@ -449,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)

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/graphblas/core/expr.py

@@ -147,13 +147,13 @@ class IndexerResolver:
         return self.indices[0]._py_index()
 
     def parse_indices(self, indices, shape):
-        """
-        Returns
+        """Returns
         -------
             [(rows, rowsize), (cols, colsize)] for Matrix
             [(idx, idx_size)] for Vector
 
         Within each tuple, if the index is of type int, the size will be None
+
         """
         if len(shape) == 1:
             if type(indices) is tuple:
@@ -312,8 +312,8 @@ class AmbiguousAssignOrExtract:
         Updater(self.parent, opts=opts)._setitem(self.resolved_indexes, expr, is_submask=False)
 
     def new(self, dtype=None, *, mask=None, input_mask=None, name=None, **opts):
-        """
-        Force extraction of the indexes into a new object
+        """Force extraction of the indexes into a new object.
+
         dtype and mask are the only controllable parameters.
         """
         if input_mask is not None:

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/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))

{python-graphblas-2023.12.0 → python_graphblas-2025.2.0}/graphblas/core/infix.py

@@ -236,7 +236,6 @@ class VectorInfixExpr(InfixExprBase):
     to_coo = wrapdoc(Vector.to_coo)(property(automethods.to_coo))
     to_dense = wrapdoc(Vector.to_dense)(property(automethods.to_dense))
     to_dict = wrapdoc(Vector.to_dict)(property(automethods.to_dict))
-    to_values = wrapdoc(Vector.to_values)(property(automethods.to_values))
     vxm = wrapdoc(Vector.vxm)(property(automethods.vxm))
     wait = wrapdoc(Vector.wait)(property(automethods.wait))
     # These raise exceptions
@@ -317,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):
@@ -396,7 +396,6 @@ class MatrixInfixExpr(InfixExprBase):
     to_dense = wrapdoc(Matrix.to_dense)(property(automethods.to_dense))
     to_dicts = wrapdoc(Matrix.to_dicts)(property(automethods.to_dicts))
     to_edgelist = wrapdoc(Matrix.to_edgelist)(property(automethods.to_edgelist))
-    to_values = wrapdoc(Matrix.to_values)(property(automethods.to_values))
     wait = wrapdoc(Matrix.wait)(property(automethods.wait))
     # These raise exceptions
     __array__ = Matrix.__array__