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

{python-graphblas-2024.2.0/python_graphblas.egg-info → python_graphblas-2025.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: python-graphblas
-Version: 2024.2.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.22
+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.13"
+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.13" and extra == "io"
-Requires-Dist: awkward>=1.9; extra == "io"
-Requires-Dist: sparse>=0.13; python_version < "3.13" 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.13" 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.13" 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-2024.2.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-2024.2.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-2024.2.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()
@@ -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)

{python-graphblas-2024.2.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-2024.2.0 → python_graphblas-2025.2.0}/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):

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

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

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

python_graphblas-2025.2.0/graphblas/core/ss/__init__.py

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

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