ENH : Adding backend_info entry point

.pre-commit-config.yaml

@@ -2,13 +2,21 @@
 # pre-commit install
 
 repos:
-  - repo: https://github.com/psf/black
-    rev: 23.9.1
+  - repo: https://github.com/adamchainz/blacken-docs
+    rev: 1.16.0
     hooks:
-      - id: black
-  - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.292
+      - id: blacken-docs
+  - repo: https://github.com/pre-commit/mirrors-prettier
+    rev: v3.1.0
+    hooks:
+      - id: prettier
+        files: \.(html|md|toml|yml|yaml)
+        args: [--prose-wrap=preserve]
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.8
     hooks:
       - id: ruff
         args:
           - --fix
+      - id: ruff-format
+

nx_parallel/algorithms/centrality/betweenness.py

@@ -7,17 +7,16 @@
     _single_source_shortest_path_basic,
 )
 from networkx.utils import py_random_state
-
 import nx_parallel as nxp
 
 __all__ = ["betweenness_centrality"]
 
 
 @py_random_state(5)
 def betweenness_centrality(
-    G, k=None, normalized=True, weight=None, endpoints=False, seed=None
+    G, k=None, normalized=True, weight=None, endpoints=False, seed=None, n_jobs=-1
 ):
-    r"""Parallel Compute shortest-path betweenness centrality for nodes
+    r"""Parallel Computes shortest-path betweenness centrality for nodes
 
     Betweenness centrality of a node $v$ is the sum of the
     fraction of all-pairs shortest paths that pass through $v$
@@ -61,6 +60,11 @@ def betweenness_centrality(
         See :ref:`Randomness<randomness>`.
         Note that this is only used if k is not None.
 
+    n_jobs : int, optional (default=-1)
+        The number of logical CPUs or cores you want to use. 
+        For `n_jobs` less than 0, (`n_cpus + 1 + n_jobs`) are used.
+        If an invalid value is given, then `n_jobs` is set to `n_cpus`.
+
     Returns
     -------
     nodes : dictionary
@@ -80,17 +84,13 @@ def betweenness_centrality(
     else:
         nodes = seed.sample(list(G.nodes), k)
 
-    total_cores = nxp.cpu_count()
-    num_in_chunk = max(len(nodes) // total_cores, 1)
+    cpu_count = nxp.cpu_count(n_jobs)
+
+    num_in_chunk = max(len(nodes) // cpu_count, 1)
     node_chunks = nxp.chunks(nodes, num_in_chunk)
 
-    bt_cs = Parallel(n_jobs=total_cores)(
-        delayed(_betweenness_centrality_node_subset)(
-            G,
-            chunk,
-            weight,
-            endpoints,
-        )
+    bt_cs = Parallel(n_jobs=cpu_count)(
+        delayed(_betweenness_centrality_node_subset)(G, chunk, weight, endpoints,)
         for chunk in node_chunks
     )
 

nx_parallel/algorithms/efficiency_measures.py

@@ -1,15 +1,12 @@
 """Provides functions for computing the efficiency of nodes and graphs."""
 import networkx as nx
 from joblib import Parallel, delayed
-
 import nx_parallel as nxp
 
 __all__ = ["local_efficiency"]
 
-"""Helper to interface between graph types"""
-
 
-def local_efficiency(G):
+def local_efficiency(G, n_jobs=-1):
     """Returns the average local efficiency of the graph.
 
     The *efficiency* of a pair of nodes in a graph is the multiplicative
@@ -23,44 +20,40 @@ def local_efficiency(G):
     G : :class:`networkx.Graph`
         An undirected graph for which to compute the average local efficiency.
 
+    n_jobs : int, optional (default=-1)
+        The number of logical CPUs or cores you want to use. 
+        For `n_jobs` less than 0, (`n_cpus + 1 + n_jobs`) are used.
+        If an invalid value is given, then `n_jobs` is set to `n_cpus`.
+
     Returns
     -------
     float
         The average local efficiency of the graph.
 
-    Examples
-    --------
-    >>> G = nx.Graph([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3)])
-    >>> nx.local_efficiency(G)
-    0.9166666666666667
-
     Notes
     -----
     Edge weights are ignored when computing the shortest path distances.
 
-    See also
-    --------
-    global_efficiency
-
     References
     ----------
     .. [1] Latora, Vito, and Massimo Marchiori.
            "Efficient behavior of small-world networks."
            *Physical Review Letters* 87.19 (2001): 198701.
            <https://doi.org/10.1103/PhysRevLett.87.198701>
     """
+
+    def _local_efficiency_node_subset(G, nodes):
+        return sum(nx.global_efficiency(G.subgraph(G[v])) for v in nodes)
+
     if hasattr(G, "graph_object"):
         G = G.graph_object
 
-    total_cores = nxp.cpu_count()
-    num_in_chunk = max(len(G.nodes) // total_cores, 1)
+    cpu_count = nxp.cpu_count()
+
+    num_in_chunk = max(len(G.nodes) // cpu_count, 1)
     node_chunks = list(nxp.chunks(G.nodes, num_in_chunk))
 
-    efficiencies = Parallel(n_jobs=total_cores)(
+    efficiencies = Parallel(n_jobs=cpu_count)(
         delayed(_local_efficiency_node_subset)(G, chunk) for chunk in node_chunks
     )
     return sum(efficiencies) / len(G)
-
-
-def _local_efficiency_node_subset(G, nodes):
-    return sum(nx.global_efficiency(G.subgraph(G[v])) for v in nodes)

nx_parallel/algorithms/isolate.py

@@ -1,12 +1,11 @@
 import networkx as nx
 from joblib import Parallel, delayed
-
 import nx_parallel as nxp
 
 __all__ = ["number_of_isolates"]
 
 
-def number_of_isolates(G):
+def number_of_isolates(G, n_jobs=-1):
     """Returns the number of isolates in the graph. Parallel implementation.
 
     An *isolate* is a node with no neighbors (that is, with degree
@@ -17,6 +16,11 @@ def number_of_isolates(G):
     ----------
     G : NetworkX graph
 
+    n_jobs : int, optional (default=-1)
+        The number of logical CPUs or cores you want to use. 
+        For `n_jobs` less than 0, (`n_cpus + 1 + n_jobs`) are used.
+        If an invalid value is given, then `n_jobs` is set to `n_cpus`.
+
     Returns
     -------
     int
@@ -25,8 +29,13 @@ def number_of_isolates(G):
     """
     if hasattr(G, "graph_object"):
         G = G.graph_object
+
+    cpu_count = nxp.cpu_count()
+
     isolates_list = list(nx.isolates(G))
-    num_in_chunk = max(len(isolates_list) // nxp.cpu_count(), 1)
+    num_in_chunk = max(len(isolates_list) // cpu_count, 1)
     isolate_chunks = nxp.chunks(isolates_list, num_in_chunk)
-    results = Parallel(n_jobs=-1)(delayed(len)(chunk) for chunk in isolate_chunks)
+    results = Parallel(n_jobs=cpu_count)(
+        delayed(len)(chunk) for chunk in isolate_chunks
+    )
     return sum(results)

nx_parallel/algorithms/shortest_paths/weighted.py

@@ -1,13 +1,12 @@
 from joblib import Parallel, delayed
 from networkx.algorithms.shortest_paths.weighted import single_source_bellman_ford_path
-
 import nx_parallel as nxp
 
 __all__ = ["all_pairs_bellman_ford_path"]
 
 
-def all_pairs_bellman_ford_path(G, weight="weight"):
-    """Compute shortest paths between all nodes in a weighted graph.
+def all_pairs_bellman_ford_path(G, weight="weight", n_jobs=-1):
+    """Computes shortest paths between all nodes in a weighted graph.
 
     Parameters
     ----------
@@ -26,6 +25,11 @@ def all_pairs_bellman_ford_path(G, weight="weight"):
         dictionary of edge attributes for that edge. The function must
         return a number.
 
+    n_jobs : int, optional (default=-1)
+        The number of logical CPUs or cores you want to use. 
+        For `n_jobs` less than 0, (`n_cpus + 1 + n_jobs`) are used.
+        If an invalid value is given, then `n_jobs` is set to `n_cpus`.
+
     Returns
     -------
     paths : iterator
@@ -45,14 +49,13 @@ def all_pairs_bellman_ford_path(G, weight="weight"):
     >>> path = dict(nx.all_pairs_bellman_ford_path(G))
     >>> path[0][2]
     [0, 1, 2]
-    >>> parallel_path = dict(nx.all_pairs_bellman_ford_path(G, backend="parallel"))
+    >>> parallel_path = dict(nx.all_pairs_bellman_ford_path(G, backend="parallel", n_jobs=3))
     >>> parallel_path[0][2]
     [0, 1, 2]
     >>> import nx_parallel as nxp
     >>> parallel_path_ = dict(nx.all_pairs_bellman_ford_path(nxp.ParallelGraph(G)))
     >>> parallel_path_
     {1: {1: [1], 0: [1, 0], 2: [1, 2]}, 0: {0: [0], 1: [0, 1], 2: [0, 1, 2]}, 2: {2: [2], 1: [2, 1], 0: [2, 1, 0]}}
-
     """
 
     def _calculate_shortest_paths_subset(source):
@@ -61,11 +64,11 @@ def _calculate_shortest_paths_subset(source):
     if hasattr(G, "graph_object"):
         G = G.graph_object
 
-    nodes = G.nodes
+    cpu_count = nxp.cpu_count(n_jobs)
 
-    total_cores = nxp.cpu_count()
+    nodes = G.nodes
 
-    paths = Parallel(n_jobs=total_cores, return_as="generator")(
+    paths = Parallel(n_jobs=cpu_count, return_as="generator")(
         delayed(_calculate_shortest_paths_subset)(source) for source in nodes
     )
     return paths

nx_parallel/algorithms/tournament.py

@@ -1,5 +1,4 @@
 from joblib import Parallel, delayed
-
 import nx_parallel as nxp
 
 __all__ = [
@@ -8,7 +7,7 @@
 ]
 
 
-def is_reachable(G, s, t):
+def is_reachable(G, s, t, n_jobs=-1):
     """Decides whether there is a path from `s` to `t` in the tournament
 
     This function is more theoretically efficient than the reachability
@@ -29,6 +28,11 @@ def is_reachable(G, s, t):
     t : node
         A node in the graph.
 
+    n_jobs : int, optional (default=-1)
+        The number of logical CPUs or cores you want to use. 
+        For `n_jobs` less than 0, (`n_cpus + 1 + n_jobs`) are used.
+        If an invalid value is given, then `n_jobs` is set to `n_cpus`.
+
     Returns
     -------
     bool
@@ -71,6 +75,8 @@ def is_reachable(G, s, t):
     G_adj = G._adj
     setG = set(G)
 
+    cpu_count = nxp.cpu_count(n_jobs)
+
     def two_nbrhood_subset(G, chunk):
         result = []
         for v in chunk:
@@ -85,22 +91,22 @@ def check_closure_subset(chunk):
         return all(not (s in S and t not in S and is_closed(G, S)) for S in chunk)
 
     # send chunk of vertices to each process (calculating neighborhoods)
-    num_in_chunk = max(len(G) // nxp.cpu_count(), 1)
+    num_in_chunk = max(len(G) // cpu_count, 1)
 
     # neighborhoods = [two_neighborhood_subset(G, chunk) for chunk in node_chunks]
-    neighborhoods = Parallel(n_jobs=-1)(
+    neighborhoods = Parallel(n_jobs=cpu_count)(
         delayed(two_nbrhood_subset)(G, chunk) for chunk in nxp.chunks(G, num_in_chunk)
     )
 
     # send chunk of neighborhoods to each process (checking closure conditions)
     nbrhoods = (nhood for nh_chunk in neighborhoods for nhood in nh_chunk)
-    results = Parallel(n_jobs=-1, backend="loky")(
+    results = Parallel(n_jobs=cpu_count)(
         delayed(check_closure_subset)(ch) for ch in nxp.chunks(nbrhoods, num_in_chunk)
     )
     return all(results)
 
 
-def tournament_is_strongly_connected(G):
+def tournament_is_strongly_connected(G, n_jobs=-1):
     """Decides whether the given tournament is strongly connected.
 
     This function is more theoretically efficient than the
@@ -114,6 +120,11 @@ def tournament_is_strongly_connected(G):
     ----------
     G : NetworkX graph
         A directed graph representing a tournament.
+
+    n_jobs : int, optional (default=-1)
+        The number of logical CPUs or cores you want to use. 
+        For `n_jobs` less than 0, (`n_cpus + 1 + n_jobs`) are used.
+        If an invalid value is given, then `n_jobs` is set to `n_cpus`.
 
     Returns
     -------
@@ -159,12 +170,14 @@ def tournament_is_strongly_connected(G):
     if hasattr(G, "graph_object"):
         G = G.graph_object
 
+    cpu_count = nxp.cpu_count()
+
     # Subset version of is_reachable
     def is_reachable_subset(G, chunk):
         return all(is_reachable(G, u, v) for v in chunk for u in G)
 
-    num_in_chunk = max(len(G) // nxp.cpu_count(), 1)
-    results = Parallel(n_jobs=-1)(
+    num_in_chunk = max(len(G) // cpu_count, 1)
+    results = Parallel(n_jobs=cpu_count)(
         delayed(is_reachable_subset)(G, ch) for ch in nxp.chunks(G, num_in_chunk)
     )
     return all(results)