Fix linting issues with ruff

Author: SKADE2303

_nx_parallel/__init__.py

@@ -90,15 +90,29 @@ def get_info():
                     'get_chunks : str, function (default = "chunks")': "A function that takes in a list of all the nodes as input and returns an iterable `node_chunks`. The default chunking is done by slicing the `nodes` into `n_jobs` number of chunks."
                 },
             },
+            "closeness_centrality": {
+                "url": "https://github.com/networkx/nx-parallel/blob/main/nx_parallel/algorithms/centrality/closeness.py#L9",
+                "additional_docs": "The parallel computation is implemented by dividing the nodes into chunks and computing closeness centrality for each chunk concurrently.",
+                "additional_parameters": {
+                    "G : graph": 'A NetworkX graph u : node, optional Return only the value for node u distance : string or function, optional The edge attribute to use as distance when computing shortest paths, or a user-defined distance function. wf_improved : bool, optional If True, use the improved formula for closeness centrality. get_chunks : str, function (default = "chunks") A function that takes in a list of all the nodes as input and returns an iterable `node_chunks`. The default chunking is done by slicing the `nodes` into `n_jobs` number of chunks.'
+                },
+            },
             "closeness_vitality": {
                 "url": "https://github.com/networkx/nx-parallel/blob/main/nx_parallel/algorithms/vitality.py#L10",
                 "additional_docs": "The parallel computation is implemented only when the node is not specified. The closeness vitality for each node is computed concurrently.",
                 "additional_parameters": {
                     'get_chunks : str, function (default = "chunks")': "A function that takes in a list of all the nodes as input and returns an iterable `node_chunks`. The default chunking is done by slicing the `nodes` into `n_jobs` number of chunks."
                 },
             },
+            "degree_centrality": {
+                "url": "https://github.com/networkx/nx-parallel/blob/main/nx_parallel/algorithms/centrality/degree.py#L8",
+                "additional_docs": "Parallel computation of degree centrality. Divides nodes into chunks and computes degree centrality for each chunk concurrently.",
+                "additional_parameters": {
+                    'get_chunks : str, function (default = "chunks")': "A function that takes in a list of all the nodes as input and returns an iterable `node_chunks`. The default chunking is done by slicing the `nodes` into `n_jobs` number of chunks."
+                },
+            },
             "edge_betweenness_centrality": {
-                "url": "https://github.com/networkx/nx-parallel/blob/main/nx_parallel/algorithms/centrality/betweenness.py#L96",
+                "url": "https://github.com/networkx/nx-parallel/blob/main/nx_parallel/algorithms/centrality/betweenness.py#L104",
                 "additional_docs": "The parallel computation is implemented by dividing the nodes into chunks and computing edge betweenness centrality for each chunk concurrently.",
                 "additional_parameters": {
                     'get_chunks : str, function (default = "chunks")': "A function that takes in a list of all the nodes as input and returns an iterable `node_chunks`. The default chunking is done by slicing the `nodes` into `n_jobs` number of chunks."

nx_parallel/algorithms/centrality/betweenness.py

@@ -52,20 +52,20 @@ def betweenness_centrality(
         node_chunks = nxp.create_iterables(G, "node", n_jobs, nodes)
     else:
         node_chunks = get_chunks(nodes)
-    
+
     # Handle empty chunks
-    if not node_chunks:  
+    if not node_chunks:
         return {}
-    
+
     bt_cs = Parallel()(
         delayed(_betweenness_centrality_node_subset)(G, chunk, weight, endpoints)
         for chunk in node_chunks
     )
 
     # Handle empty results
-    if not bt_cs: 
+    if not bt_cs:
         return {}
-    
+
     # Reducing partial solution
     bt_c = bt_cs[0]
     for bt in bt_cs[1:]:

nx_parallel/algorithms/centrality/closeness.py

@@ -45,7 +45,7 @@ def closeness_centrality(
     if u is not None:
         result = _closeness_centrality_node_subset(G, nodes, distance, wf_improved)
         return result[u]
-    
+
     n_jobs = nxp.get_n_jobs()
 
     # Validate get_chunks - the chunk parameter is only used for parallel execution
@@ -66,9 +66,7 @@ def closeness_centrality(
         return {}
 
     cc_subs = Parallel()(
-        delayed(_closeness_centrality_node_subset)(
-            G, chunk, distance, wf_improved
-        )
+        delayed(_closeness_centrality_node_subset)(G, chunk, distance, wf_improved)
         for chunk in node_chunks
     )
 
@@ -82,38 +80,38 @@ def closeness_centrality(
 def _closeness_centrality_node_subset(G, nodes, distance=None, wf_improved=True):
     """
     Compute closeness centrality for a subset of nodes.
-    
+
     Implemented to match NetworkX's implementation exactly.
     """
     # Create a copy of the graph to avoid modifying the original
     # Handle directed graphs by reversing (matches NetworkX implementation)
     if G.is_directed():
         G = G.reverse()  # create a reversed graph view
-    
+
     closeness_dict = {}
-    
+
     for n in nodes:
         # Using the exact NetworkX path calculation logic
         if distance is not None:
             # Use Dijkstra for weighted graphs
             sp = nx.single_source_dijkstra_path_length(G, n, weight=distance)
         else:
-            # Use BFS for unweighted graphs  
+            # Use BFS for unweighted graphs
             sp = nx.single_source_shortest_path_length(G, n)
-        
+
         # Sum of shortest paths exactly as NetworkX does it
         totsp = sum(sp.values())
         len_G = len(G)
         _closeness_centrality = 0.0
-        
+
         # Use the exact NetworkX formula and conditions
         if totsp > 0.0 and len_G > 1:
             _closeness_centrality = (len(sp) - 1.0) / totsp
             # Use the exact normalization formula from NetworkX
             if wf_improved:
                 s = (len(sp) - 1.0) / (len_G - 1)
                 _closeness_centrality *= s
-        
+
         closeness_dict[n] = _closeness_centrality
-    
-    return closeness_dict
+
+    return closeness_dict

nx_parallel/algorithms/centrality/degree.py

@@ -1,6 +1,5 @@
 from joblib import Parallel, delayed
 import nx_parallel as nxp
-import networkx as nx
 
 __all__ = ["degree_centrality"]
 
@@ -61,4 +60,4 @@ def _degree_centrality_node_subset(G, nodes):
 
     for node in nodes:
         part_dc[node] = G.degree[node] / (n - 1)
-    return part_dc
+    return part_dc

nx_parallel/algorithms/centrality/tests/test_closeness_centrality.py

@@ -3,6 +3,7 @@
 import math
 import pytest
 
+
 def test_betweenness_centrality_get_chunks():
     def get_chunk(nodes):
         num_chunks = nxp.get_n_jobs()
@@ -49,11 +50,11 @@ def test_betweenness_centrality_weighted_graph():
     """Test betweenness centrality on a weighted graph."""
     G = nx.fast_gnp_random_graph(100, 0.1, directed=False)
     for u, v in G.edges:
-        G[u][v]['weight'] = 1.0  # Assign uniform weights
+        G[u][v]["weight"] = 1.0  # Assign uniform weights
 
     H = nxp.ParallelGraph(G)
-    par_bc = nxp.betweenness_centrality(H, weight='weight')
-    expected_bc = nx.betweenness_centrality(G, weight='weight')
+    par_bc = nxp.betweenness_centrality(H, weight="weight")
+    expected_bc = nx.betweenness_centrality(G, weight="weight")
 
     for node in G.nodes:
         assert math.isclose(par_bc[node], expected_bc[node], abs_tol=1e-16)
@@ -78,7 +79,9 @@ def test_betweenness_centrality_empty_graph():
 
     # Check if the underlying graph is empty before calling the function
     if len(H.graph_object) == 0:  # Use the underlying graph's length
-        assert nxp.betweenness_centrality(H) == {}, "Expected an empty dictionary for an empty graph"
+        assert (
+            nxp.betweenness_centrality(H) == {}
+        ), "Expected an empty dictionary for an empty graph"
     else:
         pytest.fail("Graph is not empty, but it should be.")
 
@@ -104,7 +107,9 @@ def test_betweenness_centrality_large_graph():
     expected_bc = nx.betweenness_centrality(G)
 
     for node in G.nodes:
-        assert math.isclose(par_bc[node], expected_bc[node], abs_tol=1e-6)  # Larger tolerance for large graphs
+        assert math.isclose(
+            par_bc[node], expected_bc[node], abs_tol=1e-6
+        )  # Larger tolerance for large graphs
 
 
 def test_betweenness_centrality_multigraph():
@@ -134,6 +139,7 @@ def test_closeness_centrality_default_chunks():
 
 def test_closeness_centrality_custom_chunks():
     """Test closeness centrality with a custom chunking function."""
+
     def custom_chunking(nodes):
         # Example custom chunking: split nodes into two equal parts
         mid = len(nodes) // 2
@@ -154,7 +160,9 @@ def test_closeness_centrality_empty_graph():
     G = nx.Graph()  # An empty graph
     H = nxp.ParallelGraph(G)
 
-    assert nxp.closeness_centrality(H, get_chunks="chunks") == {}, "Expected an empty dictionary for an empty graph"
+    assert (
+        nxp.closeness_centrality(H, get_chunks="chunks") == {}
+    ), "Expected an empty dictionary for an empty graph"
 
 
 def test_closeness_centrality_single_node():
@@ -178,4 +186,4 @@ def test_closeness_centrality_large_graph():
     expected_cc = nx.closeness_centrality(G)
 
     for node in G.nodes:
-        assert pytest.approx(par_cc[node], rel=1e-6) == expected_cc[node]
+        assert pytest.approx(par_cc[node], rel=1e-6) == expected_cc[node]

nx_parallel/algorithms/centrality/tests/test_degree_centrality.py

@@ -21,6 +21,7 @@ def test_degree_centrality_default_chunks():
 
 def test_degree_centrality_custom_chunks():
     """Test degree centrality with custom chunking."""
+
     def get_chunk(nodes):
         num_chunks = nxp.get_n_jobs()
         chunks = [[] for _ in range(num_chunks)]
@@ -132,4 +133,6 @@ def test_degree_centrality_large_graph():
     expected_dc = nx.degree_centrality(G)
 
     for node in G.nodes:
-        assert math.isclose(par_dc[node], expected_dc[node], abs_tol=1e-6)  # Larger tolerance for large graphs
+        assert math.isclose(
+            par_dc[node], expected_dc[node], abs_tol=1e-6
+        )  # Larger tolerance for large graphs

timing/timing_all_functions.py

@@ -56,15 +56,21 @@
     G = nx.tournament.random_tournament(num)
     H = nx_parallel.ParallelGraph(G)
     t1 = time.time()
-    c = nx.tournament.is_reachable(H, 0, num - 1)  # Provide source (0) and target (num - 1)
+    c = nx.tournament.is_reachable(
+        H, 0, num - 1
+    )  # Provide source (0) and target (num - 1)
     t2 = time.time()
     parallelTime = t2 - t1
     t1 = time.time()
-    c = nx.tournament.is_reachable(G, 0, num - 1)  # Provide source (0) and target (num - 1)
+    c = nx.tournament.is_reachable(
+        G, 0, num - 1
+    )  # Provide source (0) and target (num - 1)
     t2 = time.time()
     stdTime = t2 - t1
     timesFaster = stdTime / parallelTime
-    heatmapDF.at[j, len(function_list)] = timesFaster  # Add this as a new row in the heatmap
+    heatmapDF.at[j, len(function_list)] = (
+        timesFaster  # Add this as a new row in the heatmap
+    )
     print("Finished nx.tournament.is_reachable")
 
 # plotting the heatmap with numbers and a green color scheme
@@ -81,7 +87,7 @@
 ]
 
 # Ensure the number of labels matches the number of rows in heatmapDF
-hm.set_yticklabels(labels[:len(heatmapDF.columns)])
+hm.set_yticklabels(labels[: len(heatmapDF.columns)])
 
 # Adding x-axis labels
 hm.set_xticklabels(number_of_nodes_list)