Add ruff as pre-commit hook (#46)

Author: eriknw

.flake8

@@ -12,6 +12,4 @@ extend-ignore =
 # E203 whitespace before ':' (to be compatible with black)
 per-file-ignores =
     __init__.py:F401,F403,  # allow unused and star imports
-    test_*.py:F401,F403,
     graphblas_algorithms/nxapi/exception.py:F401,
-    graphblas_algorithms/**/__init__.py:F401,F403

.pre-commit-config.yaml

@@ -47,6 +47,7 @@ repos:
     rev: 23.1.0
     hooks:
       - id: black
+      # - id: black-jupyter
   - repo: https://github.com/PyCQA/flake8
     rev: 6.0.0
     hooks:
@@ -69,6 +70,10 @@ repos:
         types_or: [python, rst, markdown]
         additional_dependencies: [tomli]
         files: ^(graphblas_algorithms|docs)/
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.249
+    hooks:
+      - id: ruff
   - repo: https://github.com/pre-commit/pre-commit-hooks
     rev: v4.4.0
     hooks:

graphblas_algorithms/algorithms/cluster.py

@@ -178,21 +178,19 @@ def average_clustering(G, *, count_zeros=True, weighted=False, mask=None):
     val = c.reduce().get(0)
     if not count_zeros:
         return val / c.nvals
-    elif mask is not None:
+    if mask is not None:
         return val / mask.parent.nvals
-    else:
-        return val / c.size
+    return val / c.size
 
 
 def average_clustering_directed(G, *, count_zeros=True, weighted=False, mask=None):
     c = clustering_directed(G, weighted=weighted, mask=mask)
     val = c.reduce().get(0)
     if not count_zeros:
         return val / c.nvals
-    elif mask is not None:
+    if mask is not None:
         return val / mask.parent.nvals
-    else:
-        return val / c.size
+    return val / c.size
 
 
 def single_square_clustering(G, idx):

graphblas_algorithms/algorithms/core.py

@@ -21,7 +21,7 @@ def k_truss(G: Graph, k) -> Graph:
         C = Matrix("int32", S.nrows, S.ncols)
         while True:
             C(S.S, replace) << plus_pair(S @ S.T)
-            C << select.value(C >= k - 2)
+            C << select.value(k - 2 <= C)
             if C.nvals == nvals_last:
                 break
             nvals_last = C.nvals

graphblas_algorithms/algorithms/regular.py

@@ -10,18 +10,17 @@ def is_regular(G):
             return False
         d = degrees.get(0)
         return (degrees == d).reduce(monoid.land).get(True)
-    else:
-        row_degrees = G.get_property("row_degrees+")
-        if row_degrees.nvals != row_degrees.size:
-            return False
-        column_degrees = G.get_property("column_degrees+")
-        if column_degrees.nvals != column_degrees.size:
-            return False
-        d = row_degrees.get(0)
-        if not (row_degrees == d).reduce(monoid.land):
-            return False
-        d = column_degrees.get(0)
-        return (column_degrees == d).reduce(monoid.land).get(True)
+    row_degrees = G.get_property("row_degrees+")
+    if row_degrees.nvals != row_degrees.size:
+        return False
+    column_degrees = G.get_property("column_degrees+")
+    if column_degrees.nvals != column_degrees.size:
+        return False
+    d = row_degrees.get(0)
+    if not (row_degrees == d).reduce(monoid.land):
+        return False
+    d = column_degrees.get(0)
+    return (column_degrees == d).reduce(monoid.land).get(True)
 
 
 def is_k_regular(G, k):

graphblas_algorithms/algorithms/shortest_paths/weighted.py

@@ -75,7 +75,7 @@ def single_source_bellman_ford_path_length(G, source):
 
 
 def bellman_ford_path_lengths(G, nodes=None, *, expand_output=False):
-    """
+    """Extra parameter: expand_output
 
     Parameters
     ----------

graphblas_algorithms/classes/_caching.py

@@ -15,12 +15,12 @@ def get_reduction(G, mask=None):
             if mask is not None:
                 if key in cache:
                     return cache[key].dup(mask=mask)
-                elif cache.get("has_self_edges") is False and f"{keybase}+" in cache:
+                if cache.get("has_self_edges") is False and f"{keybase}+" in cache:
                     cache[key] = cache[f"{keybase}+"]
                     return cache[key].dup(mask=mask)
-                elif "offdiag" in cache:
+                if "offdiag" in cache:
                     return getattr(cache["offdiag"], methodname)(op_).new(mask=mask, name=key)
-                elif (
+                if (
                     "L-" in cache
                     and "U-" in cache
                     and opclass in {"BinaryOp", "Monoid"}
@@ -30,12 +30,9 @@ def get_reduction(G, mask=None):
                         getattr(cache["L-"], methodname)(op_).new(mask=mask)
                         | getattr(cache["U-"], methodname)(op_).new(mask=mask)
                     ).new(name=key)
-                elif not G.get_property("has_self_edges"):
+                if not G.get_property("has_self_edges"):
                     return G.get_property(f"{keybase}+", mask=mask)
-                else:
-                    return getattr(G.get_property("offdiag"), methodname)(op_).new(
-                        mask=mask, name=key
-                    )
+                return getattr(G.get_property("offdiag"), methodname)(op_).new(mask=mask, name=key)
             if key not in cache:
                 if cache.get("has_self_edges") is False and f"{keybase}+" in cache:
                     cache[key] = cache[f"{keybase}+"]
@@ -73,13 +70,12 @@ def get_reduction(G, mask=None):
             if mask is not None:
                 if key in cache:
                     return cache[key].dup(mask=mask)
-                elif cache.get("has_self_edges") is False and f"{keybase}-" in cache:
+                if cache.get("has_self_edges") is False and f"{keybase}-" in cache:
                     cache[key] = cache[f"{keybase}-"]
                     return cache[key].dup(mask=mask)
-                elif methodname == "reduce_columnwise" and "AT" in cache:
+                if methodname == "reduce_columnwise" and "AT" in cache:
                     return cache["AT"].reduce_rowwise(op_).new(mask=mask, name=key)
-                else:
-                    return getattr(A, methodname)(op_).new(mask=mask, name=key)
+                return getattr(A, methodname)(op_).new(mask=mask, name=key)
             if key not in cache:
                 if cache.get("has_self_edges") is False and f"{keybase}-" in cache:
                     cache[key] = cache[f"{keybase}-"]
@@ -185,5 +181,5 @@ def get_reduction(G, mask=None):
             return cache[key]
 
     else:  # pragma: no cover (sanity)
-        raise RuntimeError()
+        raise RuntimeError
     return get_reduction

graphblas_algorithms/classes/_utils.py

@@ -193,25 +193,24 @@ def matrix_to_dicts(self, A, *, use_row_index=False, use_column_index=False, val
         return {
             row: dict(zip(col_indices[start:stop], values[start:stop])) for row, (start, stop) in it
         }
-    elif use_row_index:
+    if use_row_index:
         return {
             row: {
                 id_to_key[col]: val for col, val in zip(col_indices[start:stop], values[start:stop])
             }
             for row, (start, stop) in it
         }
-    elif use_column_index:
+    if use_column_index:
         return {
             id_to_key[row]: dict(zip(col_indices[start:stop], values[start:stop]))
             for row, (start, stop) in it
         }
-    else:
-        return {
-            id_to_key[row]: {
-                id_to_key[col]: val for col, val in zip(col_indices[start:stop], values[start:stop])
-            }
-            for row, (start, stop) in it
+    return {
+        id_to_key[row]: {
+            id_to_key[col]: val for col, val in zip(col_indices[start:stop], values[start:stop])
         }
+        for row, (start, stop) in it
+    }
 
 
 def to_networkx(self, edge_attribute="weight"):

graphblas_algorithms/classes/digraph.py

@@ -119,24 +119,20 @@ def get_recip_degreesp(G, mask=None):
     """pair(A & A.T).reduce_rowwise()"""
     A = G._A
     cache = G._cache
-    if "AT" in cache:
-        AT = cache["AT"]
-    else:
-        AT = A.T
+    AT = cache.get("AT", A.T)
     if mask is not None:
         if "recip_degrees+" in cache:
             return cache["recip_degrees+"].dup(mask=mask)
-        elif cache.get("has_self_edges") is False and "recip_degrees-" in cache:
+        if cache.get("has_self_edges") is False and "recip_degrees-" in cache:
             cache["recip_degrees+"] = cache["recip_degrees-"]
             return cache["recip_degrees-"].dup(mask=mask)
-        elif "recip_degrees-" in cache and "diag" in cache:
+        if "recip_degrees-" in cache and "diag" in cache:
             return (unary.one(cache["diag"]) + cache["recip_degrees-"]).new(
                 mask=mask, name="recip_degrees+"
             )
-        elif "recip_degrees-" in cache and not G.get_property("has_self_edges"):
+        if "recip_degrees-" in cache and not G.get_property("has_self_edges"):
             return cache["recip_degrees-"].dup(mask=mask)
-        else:
-            return binary.pair(A & AT).reduce_rowwise().new(mask=mask, name="recip_degrees+")
+        return binary.pair(A & AT).reduce_rowwise().new(mask=mask, name="recip_degrees+")
     if "recip_degrees+" not in cache:
         if cache.get("has_self_edges") is False and "recip_degrees-" in cache:
             cache["recip_degrees+"] = cache["recip_degrees-"]
@@ -174,34 +170,33 @@ def get_recip_degreesm(G, mask=None):
     if mask is not None:
         if "recip_degrees-" in cache:
             return cache["recip_degrees-"].dup(mask=mask)
-        elif cache.get("has_self_edges") is False and "recip_degrees+" in cache:
+        if cache.get("has_self_edges") is False and "recip_degrees+" in cache:
             cache["recip_degrees-"] = cache["recip_degrees+"]
             return cache["recip_degrees-"].dup(mask=mask)
-        elif "recip_degrees+" in cache and "diag" in cache:
+        if "recip_degrees+" in cache and "diag" in cache:
             rv = binary.minus(cache["recip_degrees+"] | unary.one(cache["diag"])).new(
                 mask=mask, name="recip_degrees-"
             )
             rv(rv.V, replace) << rv  # drop 0s
             return rv
-        elif not G.get_property("has_self_edges"):
+        if not G.get_property("has_self_edges"):
             return G.get_property("recip_degrees+", mask=mask)
-        elif "offdiag" in cache:
+        if "offdiag" in cache:
             return (
                 binary.pair(cache["offdiag"] & AT)
                 .reduce_rowwise()
                 .new(mask=mask, name="recip_degrees-")
             )
-        elif "L-" in cache and "U-" in cache:
+        if "L-" in cache and "U-" in cache:
             return (
                 binary.pair(cache["L-"] & AT).reduce_rowwise().new(mask=mask)
                 + binary.pair(cache["U-"] & AT).reduce_rowwise().new(mask=mask)
             ).new(name="recip_degrees-")
-        else:
-            diag = G.get_property("diag", mask=mask)
-            overlap = binary.pair(A & AT).reduce_rowwise().new(mask=mask)
-            rv = binary.minus(overlap | unary.one(diag)).new(name="recip_degrees-")
-            rv(rv.V, replace) << rv  # drop 0s
-            return rv
+        diag = G.get_property("diag", mask=mask)
+        overlap = binary.pair(A & AT).reduce_rowwise().new(mask=mask)
+        rv = binary.minus(overlap | unary.one(diag)).new(name="recip_degrees-")
+        rv(rv.V, replace) << rv  # drop 0s
+        return rv
     if "recip_degrees-" not in cache:
         if cache.get("has_self_edges") is False and "recip_degrees+" in cache:
             cache["recip_degrees-"] = cache["recip_degrees+"]
@@ -245,14 +240,12 @@ def get_total_degreesp(G, mask=None):
     if mask is not None:
         if "total_degrees+" in cache:
             return cache["total_degrees+"].dup(mask=mask)
-        elif cache.get("has_self_edges") is False and "total_degrees-" in cache:
+        if cache.get("has_self_edges") is False and "total_degrees-" in cache:
             cache["total_degrees+"] = cache["total_degrees-"]
             return cache["total_degrees+"].dup(mask=mask)
-        else:
-            return (
-                G.get_property("row_degrees+", mask=mask)
-                + G.get_property("column_degrees+", mask=mask)
-            ).new(name="total_degrees+")
+        return (
+            G.get_property("row_degrees+", mask=mask) + G.get_property("column_degrees+", mask=mask)
+        ).new(name="total_degrees+")
     if "total_degrees+" not in cache:
         if cache.get("has_self_edges") is False and "total_degrees-" in cache:
             cache["total_degrees+"] = cache["total_degrees-"]
@@ -277,14 +270,12 @@ def get_total_degreesm(G, mask=None):
     if mask is not None:
         if "total_degrees-" in cache:
             return cache["total_degrees-"].dup(mask=mask)
-        elif cache.get("has_self_edges") is False and "total_degrees+" in cache:
+        if cache.get("has_self_edges") is False and "total_degrees+" in cache:
             cache["total_degrees-"] = cache["total_degrees+"]
             return cache["total_degrees-"].dup(mask=mask)
-        else:
-            return (
-                G.get_property("row_degrees-", mask=mask)
-                + G.get_property("column_degrees-", mask=mask)
-            ).new(name="total_degrees-")
+        return (
+            G.get_property("row_degrees-", mask=mask) + G.get_property("column_degrees-", mask=mask)
+        ).new(name="total_degrees-")
     if "total_degrees-" not in cache:
         if cache.get("has_self_edges") is False and "total_degrees+" in cache:
             cache["total_degrees-"] = cache["total_degrees+"]
@@ -313,10 +304,7 @@ def get_total_recipp(G, mask=None):
         elif "recip_degrees+" in cache:
             cache["total_recip+"] = cache["recip_degrees+"].reduce().get(0)
         else:
-            if "AT" in cache:
-                AT = cache["AT"]
-            else:
-                AT = A.T
+            AT = cache.get("AT", A.T)
             cache["total_recip+"] = binary.pair(A & AT).reduce_scalar().get(0)
     if "has_self_edges" not in cache and "total_recip-" in cache:
         cache["has_self_edges"] = cache["total_recip+"] > cache["total_recip-"]
@@ -398,8 +386,7 @@ def to_directed_graph(G, weight=None, dtype=None):
             return DiGraph.from_networkx(G, weight=weight, dtype=dtype)
     except ImportError:
         pass
-
-    raise TypeError()
+    raise TypeError
 
 
 def to_graph(G, weight=None, dtype=None):
@@ -420,8 +407,7 @@ def to_graph(G, weight=None, dtype=None):
             return ga.Graph.from_networkx(G, weight=weight, dtype=dtype)
     except ImportError:
         pass
-
-    raise TypeError()
+    raise TypeError
 
 
 class AutoDict(dict):

graphblas_algorithms/classes/graph.py

@@ -266,7 +266,7 @@ def to_undirected_graph(G, weight=None, dtype=None):
     except ImportError:
         pass
 
-    raise TypeError()
+    raise TypeError
 
 
 class AutoDict(dict):

graphblas_algorithms/classes/nodemap.py

@@ -255,7 +255,7 @@ def __setitem__(self, key, val):
         elif isinstance(val, dict):
             val = Vector.from_dict(val, self.matrix.dtype, size=self.matrix.ncols)
         else:
-            raise TypeError()
+            raise TypeError
         if val.nvals == 0:
             del self.matrix[idx, :]
             if self._rows is not None:
@@ -379,7 +379,7 @@ def __setitem__(self, key, val):
         elif isinstance(val, dict):
             val = Vector.from_dict(val, self.matrix.dtype, size=self.matrix.ncols)
         else:
-            raise TypeError()
+            raise TypeError
         if val.nvals == 0:
             del self.matrix[idx, :]
             if self._rows is not None:

graphblas_algorithms/nxapi/cluster.py

@@ -46,8 +46,7 @@ def clustering(G, nodes=None, weight=None):
     if nodes in G:
         if G.is_directed():
             return algorithms.single_clustering_directed(G, nodes, weighted=weighted)
-        else:
-            return algorithms.single_clustering(G, nodes, weighted=weighted)
+        return algorithms.single_clustering(G, nodes, weighted=weighted)
     mask = G.list_to_mask(nodes)
     if G.is_directed():
         result = algorithms.clustering_directed(G, weighted=weighted, mask=mask)
@@ -59,7 +58,7 @@ def clustering(G, nodes=None, weight=None):
 def average_clustering(G, nodes=None, weight=None, count_zeros=True):
     G = to_graph(G, weight=weight)  # to directed or undirected
     if len(G) == 0:
-        raise ZeroDivisionError()
+        raise ZeroDivisionError
     weighted = weight is not None
     mask = G.list_to_mask(nodes)
     if G.is_directed():
@@ -74,8 +73,7 @@ def average_clustering(G, nodes=None, weight=None, count_zeros=True):
             weighted=weighted,
             count_zeros=count_zeros,
         )
-    else:
-        return func(G, weighted=weighted, count_zeros=count_zeros, mask=mask)
+    return func(G, weighted=weighted, count_zeros=count_zeros, mask=mask)
 
 
 def _split(L, k):

graphblas_algorithms/nxapi/link_analysis/hits_alg.py

@@ -16,8 +16,7 @@ def hits(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
     except algorithms.exceptions.ConvergenceFailure as e:
         if max_iter < 1:
             raise ValueError(*e.args) from e
-        else:
-            raise ArpackNoConvergence(*e.args, (), ()) from e
+        raise ArpackNoConvergence(*e.args, (), ()) from e
         # TODO: it would be nice if networkx raised their own exception, such as:
         # raise nx.PowerIterationFailedConvergence(*e.args) from e
     return G.vector_to_nodemap(h, fill_value=0), G.vector_to_nodemap(a, fill_value=0)