fix: revert only functional change from last commit

Author: dPys

nx_parallel/algorithms/centrality/tests/test_betweenness_centrality.py

@@ -7,41 +7,34 @@ def test_edge_betweenness_centrality_get_chunks():
     def get_chunk(edges):
         num_chunks = nxp.get_n_jobs()
 
-        # Convert edges to a list to support slicing
         edges = list(edges)
 
         # Split edges into chunks without relying on precomputed centrality
         chunk_size = max(1, len(edges) // num_chunks)
         chunks = [edges[i : i + chunk_size] for i in range(0, len(edges), chunk_size)]
 
-        # Debugging: Print how edges are distributed among chunks
         print(f"Chunks distribution: {chunks}")
 
         return chunks
 
-    # Create a random graph
     G = nx.fast_gnp_random_graph(100, 0.1, directed=False)
-    H = nxp.ParallelGraph(G)  # Wrap the graph in ParallelGraph
+    H = nxp.ParallelGraph(G)
 
-    # Compute edge betweenness centrality using NetworkX
     ebc = nx.edge_betweenness_centrality(G, normalized=True)
 
-    # Debugging: Print the edge betweenness centrality values from NetworkX
     print(f"NetworkX Edge Betweenness Centrality: {ebc}")
 
-    # Instantiate the BackendInterface
     backend = nxp.BackendInterface()
 
     # Smoke test for edge_betweenness_centrality with custom get_chunks
     par_bc_chunk = backend.edge_betweenness_centrality(
-        H.graph_object,  # Pass the underlying NetworkX graph
-        get_chunks=get_chunk,  # Pass the custom get_chunks function
+        H.graph_object,
+        get_chunks=get_chunk,
     )
 
-    # Debugging: Print the results from parallel computation
     print(f"Parallel Computed Edge Betweenness Centrality: {par_bc_chunk}")
 
-    # Compare with standard NetworkX edge betweenness centrality
+    # Compare with standard edge betweenness centrality
     standard_bc = nx.edge_betweenness_centrality(G, normalized=True)
 
     for edge in standard_bc:

nx_parallel/interface.py

@@ -81,9 +81,9 @@ def __setstate__(self, state):
 def assign_algorithms(cls):
     """Class decorator to assign algorithms to the class attributes."""
     for attr in ALGORITHMS:
-        func_name = attr.rsplit(".", 1)[-1]
-        func = attrgetter(attr)(algorithms)
-        setattr(cls, func_name, staticmethod(func))
+        setattr(
+            cls, attr.rsplit(".", 1)[-1], staticmethod(attrgetter(attr)(algorithms))
+        )
     return cls
 
 

nx_parallel/tests/test_get_chunks.py

@@ -84,9 +84,8 @@ def iterator_func(G):
                     H, process_func, iterator_func, get_chunks=random_chunking
                 )
                 if isinstance(c1, types.GeneratorType):
-                    c1, c2 = (
-                        list(c1),
-                        list(c2),
+                    c1, c2 = list(c1), list(
+                        c2
                     )  # Convert generators to lists for comparison
                     if func in chk_dict_vals:
                         for i in range(len(G.nodes)):

nx_parallel/utils/tests/test_chunk.py

@@ -27,7 +27,7 @@ def test_get_n_jobs():
         with patch("joblib.parallel.get_active_backend", return_value=("loky", 3)):
             assert nxp.get_n_jobs() == 3
 
-        # Test with n_jobs set in NetworkX config
+        # Test with n_jobs set in NX config
         nx.config.backends.parallel.active = True
         nx.config.backends.parallel.n_jobs = 5
         assert nxp.get_n_jobs() == 5
@@ -59,13 +59,11 @@ def test_execute_parallel_basic():
     G = nx.path_graph(10)
     H = nxp.ParallelGraph(G)
 
-    # Define a simple process_func that calculates the degree of each node in the chunk
     def process_func(G, chunk, **kwargs):
         return {node: G.degree(node) for node in chunk}
 
-    # Define an iterator_func that returns all nodes
     def iterator_func(G):
-        return list(G.nodes())  # Convert NodeView to list
+        return list(G.nodes())
 
     # Execute in parallel without overrides
     results = nxp.execute_parallel(
@@ -85,17 +83,14 @@ def iterator_func(G):
 def test_execute_parallel_with_overrides():
     """Test `execute_parallel` with overridden parallel configuration."""
 
-    # Create a simple graph
     G = nx.complete_graph(5)
     H = nxp.ParallelGraph(G)
 
-    # Define a simple process_func that returns the list of nodes in the chunk
     def process_func(G, chunk, **kwargs):
         return list(chunk)
 
-    # Define an iterator_func that returns all nodes
     def iterator_func(G):
-        return list(G.nodes())  # Convert NodeView to list
+        return list(G.nodes())
 
     # Mock joblib.Parallel in the correct module
     with patch("nx_parallel.utils.chunk.Parallel") as mock_parallel:
@@ -123,11 +118,9 @@ def test_execute_parallel_callable_chunks():
     G = nx.cycle_graph(6)
     H = nxp.ParallelGraph(G)
 
-    # Define a process_func that sums node numbers in the chunk
     def process_func(G, chunk, **kwargs):
         return sum(chunk)
 
-    # Define an iterator_func that returns all nodes as a list
     def iterator_func(G):
         return list(G.nodes())  # Convert NodeView to list
 
@@ -151,17 +144,14 @@ def custom_chunking(data):
 def test_parallel_config_override():
     """Test that `parallel_config` correctly overrides config within its context."""
 
-    # Define a simple graph
     G = nx.complete_graph(5)
     H = nxp.ParallelGraph(G)
 
-    # Define a simple process_func that returns the list of nodes in the chunk
     def process_func(G, chunk, **kwargs):
         return list(chunk)
 
-    # Define an iterator_func that returns all nodes
     def iterator_func(G):
-        return list(G.nodes())  # Convert NodeView to list
+        return list(G.nodes())
 
     # Mock joblib.Parallel to capture the parameters it's called with
     with patch("nx_parallel.utils.chunk.Parallel") as mock_parallel:
@@ -189,11 +179,9 @@ def test_parallel_config_nested_overrides():
     G = nx.complete_graph(5)
     H = nxp.ParallelGraph(G)
 
-    # Define a simple process_func
     def process_func(G, chunk, **kwargs):
         return list(chunk)
 
-    # Define an iterator_func
     def iterator_func(G):
         return list(G.nodes())