Chore/style cleanup utility functions

.gitignore

@@ -135,3 +135,6 @@ html/
 
 # get_info update script
 temp__init__.py
+.history/
+
+.DS_Store

_nx_parallel/update_get_info.py

@@ -20,7 +20,7 @@ def get_funcs_info():
 
     nx_parallel_dir = os.path.join(os.getcwd(), "nx_parallel")
     for root, dirs, files in os.walk(nx_parallel_dir):
-        if root[-29:] == "nx-parallel/nx_parallel/utils":
+        if "nx_parallel/utils" in root:
             continue
         for file in files:
             if (

nx_parallel/interface.py

@@ -1,50 +1,64 @@
-from nx_parallel.algorithms.bipartite.redundancy import node_redundancy
-from nx_parallel.algorithms.centrality.betweenness import (
-    betweenness_centrality,
-    edge_betweenness_centrality,
-)
-from nx_parallel.algorithms.shortest_paths.generic import all_pairs_all_shortest_paths
-from nx_parallel.algorithms.shortest_paths.weighted import (
-    all_pairs_dijkstra,
-    all_pairs_dijkstra_path_length,
-    all_pairs_dijkstra_path,
-    all_pairs_bellman_ford_path_length,
-    all_pairs_bellman_ford_path,
-    johnson,
-)
-from nx_parallel.algorithms.shortest_paths.unweighted import (
-    all_pairs_shortest_path,
-    all_pairs_shortest_path_length,
-)
-from nx_parallel.algorithms.efficiency_measures import local_efficiency
-from nx_parallel.algorithms.isolate import number_of_isolates
-from nx_parallel.algorithms.tournament import (
-    is_reachable,
-    tournament_is_strongly_connected,
-)
-from nx_parallel.algorithms.vitality import closeness_vitality
-from nx_parallel.algorithms.approximation.connectivity import (
-    approximate_all_pairs_node_connectivity,
-)
-from nx_parallel.algorithms.connectivity import connectivity
-from nx_parallel.algorithms.cluster import square_clustering
+from typing import Union
+from operator import attrgetter
+
 import networkx as nx
 
+from nx_parallel import algorithms
+
 __all__ = ["BackendInterface", "ParallelGraph"]
 
+NX_GTYPES = Union[nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+
+ALGORITHMS = [
+    # Bipartite
+    "node_redundancy",
+    # Isolates
+    "number_of_isolates",
+    # Vitality
+    "closeness_vitality",
+    # Tournament
+    "is_reachable",
+    "tournament_is_strongly_connected",
+    # Centrality
+    "betweenness_centrality",
+    "edge_betweenness_centrality",
+    # Efficiency
+    "local_efficiency",
+    # Shortest Paths : generic
+    "all_pairs_all_shortest_paths",
+    # Shortest Paths : weighted graphs
+    "all_pairs_dijkstra",
+    "all_pairs_dijkstra_path_length",
+    "all_pairs_dijkstra_path",
+    "all_pairs_bellman_ford_path_length",
+    "all_pairs_bellman_ford_path",
+    "johnson",
+    # Clustering
+    "square_clustering",
+    # Shortest Paths : unweighted graphs
+    "all_pairs_shortest_path",
+    "all_pairs_shortest_path_length",
+    # Approximation
+    "approximate_all_pairs_node_connectivity",
+    # Connectivity
+    "connectivity.all_pairs_node_connectivity",
+]
+
 
 class ParallelGraph:
     """A wrapper class for networkx.Graph, networkx.DiGraph, networkx.MultiGraph,
-    and networkx.MultiDiGraph."""
+    and networkx.MultiDiGraph.
+    """
 
     __networkx_backend__ = "parallel"
 
-    def __init__(self, graph_object=None):
+    def __init__(
+        self,
+        graph_object,
+    ):
         if graph_object is None:
             self.graph_object = nx.Graph()
-        elif isinstance(
-            graph_object, (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)
-        ):
+        elif isinstance(graph_object, NX_GTYPES):
             self.graph_object = graph_object
         else:
             self.graph_object = nx.Graph(graph_object)
@@ -56,70 +70,36 @@ def is_directed(self):
         return self.graph_object.is_directed()
 
     def __str__(self):
-        return "Parallel" + str(self.graph_object)
+        return f"Parallel{self.graph_object}"
 
 
-class BackendInterface:
-    """BackendInterface class for parallel algorithms."""
+def assign_algorithms(cls):
+    """Class decorator to assign algorithms to the class attributes."""
+    for attr in ALGORITHMS:
+        # get the function name by parsing the module hierarchy
+        func_name = attr.rsplit(".", 1)[-1]
+        setattr(cls, func_name, attrgetter(attr)(algorithms))
+    return cls
 
-    # Bipartite
-    node_redundancy = node_redundancy
 
-    # Isolates
-    number_of_isolates = number_of_isolates
-
-    # Vitality
-    closeness_vitality = closeness_vitality
-
-    # Tournament
-    is_reachable = is_reachable
-    tournament_is_strongly_connected = tournament_is_strongly_connected
-
-    # Centrality
-    betweenness_centrality = betweenness_centrality
-    edge_betweenness_centrality = edge_betweenness_centrality
-
-    # Efficiency
-    local_efficiency = local_efficiency
-
-    # Shortest Paths : generic
-    all_pairs_all_shortest_paths = all_pairs_all_shortest_paths
-
-    # Shortest Paths : weighted graphs
-    all_pairs_dijkstra = all_pairs_dijkstra
-    all_pairs_dijkstra_path_length = all_pairs_dijkstra_path_length
-    all_pairs_dijkstra_path = all_pairs_dijkstra_path
-    all_pairs_bellman_ford_path_length = all_pairs_bellman_ford_path_length
-    all_pairs_bellman_ford_path = all_pairs_bellman_ford_path
-    johnson = johnson
-
-    # Clustering
-    square_clustering = square_clustering
-
-    # Shortest Paths : unweighted graphs
-    all_pairs_shortest_path = all_pairs_shortest_path
-    all_pairs_shortest_path_length = all_pairs_shortest_path_length
-
-    # Approximation
-    approximate_all_pairs_node_connectivity = approximate_all_pairs_node_connectivity
-
-    # Connectivity
-    all_pairs_node_connectivity = connectivity.all_pairs_node_connectivity
-
-    # =============================
+@assign_algorithms
+class BackendInterface:
+    """BackendInterface class for parallel algorithms."""
 
     @staticmethod
     def convert_from_nx(graph, *args, **kwargs):
         """Convert a networkx.Graph, networkx.DiGraph, networkx.MultiGraph,
-        or networkx.MultiDiGraph to a ParallelGraph."""
+        or networkx.MultiDiGraph to a ParallelGraph.
+        """
         if isinstance(graph, ParallelGraph):
             return graph
         return ParallelGraph(graph)
 
     @staticmethod
     def convert_to_nx(result, *, name=None):
         """Convert a ParallelGraph to a networkx.Graph, networkx.DiGraph,
-        networkx.MultiGraph, or networkx.MultiDiGraph."""
+        networkx.MultiGraph, or networkx.MultiDiGraph.
+        """
         if isinstance(result, ParallelGraph):
             return result.graph_object
         return result

nx_parallel/tests/test_get_chunks.py

@@ -2,11 +2,12 @@
 
 import inspect
 import importlib
-import networkx as nx
-import nx_parallel as nxp
 import random
 import types
 import math
+import networkx as nx
+
+import nx_parallel as nxp
 
 
 def get_all_functions(package_name="nx_parallel"):

nx_parallel/utils/chunk.py

@@ -1,66 +1,99 @@
 import itertools
 import os
+
 import networkx as nx
 
+from nx_parallel.utils.types import GraphIteratorType
+
+
 __all__ = ["chunks", "get_n_jobs", "create_iterables"]
 
 
-def chunks(iterable, n):
-    """Divides an iterable into chunks of size n"""
+def chunks(iterable, n_chunks):
+    """Yield exactly `n_chunks` chunks from `iterable`, balancing the chunk sizes."""
+    iterable = list(iterable)
+    k, m = divmod(len(iterable), n_chunks)
     it = iter(iterable)
-    while True:
-        x = tuple(itertools.islice(it, n))
-        if not x:
-            return
-        yield x
+    for _ in range(n_chunks):
+        chunk_size = k + (1 if m > 0 else 0)
+        m -= 1
+        yield tuple(itertools.islice(it, chunk_size))
 
 
 def get_n_jobs(n_jobs=None):
-    """Returns the positive value of `n_jobs`."""
+    """Return the positive value of `n_jobs`, adjusting for the environment.
+
+    If running under pytest, returns 2 jobs. If using a parallel backend,
+    returns the number of jobs configured for the backend. Otherwise, returns
+    the number of CPUs adjusted for negative `n_jobs` values.
+    """
     if "PYTEST_CURRENT_TEST" in os.environ:
         return 2
-    else:
+
+    if n_jobs == 0:
+        raise ValueError("n_jobs == 0 in Parallel has no meaning")
+
+    if not n_jobs:
         if nx.config.backends.parallel.active:
             n_jobs = nx.config.backends.parallel.n_jobs
         else:
             from joblib.parallel import get_active_backend
 
             n_jobs = get_active_backend()[1]
-        n_cpus = os.cpu_count()
-        if n_jobs is None:
-            return 1
-        if n_jobs < 0:
-            return n_cpus + n_jobs + 1
-        if n_jobs == 0:
-            raise ValueError("n_jobs == 0 in Parallel has no meaning")
-        return int(n_jobs)
-
-
-def create_iterables(G, iterator, n_cores, list_of_iterator=None):
-    """Creates an iterable of function inputs for parallel computation
+
+    if not n_jobs:
+        return 1  # Default to 1 if no valid n_jobs is found or passed
+    if n_jobs < 0:
+        return os.cpu_count() + n_jobs + 1
+
+    return int(n_jobs)
+
+
+def create_iterables(
+    G,
+    iterator,
+    n_cores,
+    list_of_iterator=None,
+):
+    """Create an iterable of function inputs for parallel computation
     based on the provided iterator type.
 
     Parameters
-    -----------
+    ----------
     G : NetworkX graph
-    iterator : str
-        Type of iterator. Valid values are 'node', 'edge', 'isolate'
+        The NetworkX graph.
+    iterator : GraphIteratorType
+        Type of iterator. Valid values are 'NODE', 'EDGE', 'ISOLATE'.
+    n_cores : int
+        The number of cores to use.
+    list_of_iterator : list, optional
+        A precomputed list of items to iterate over. If None, it will
+        be generated based on the iterator type.
 
-    Returns:
-    --------
-    iterable : Iterable
+    Returns
+    -------
+    iterable
         An iterable of function inputs.
+
+    Raises
+    ------
+    ValueError
+        If the iterator type is not valid.
     """
+    if isinstance(iterator, str):
+        iterator = GraphIteratorType(iterator)
+
+    if not list_of_iterator:
+        if iterator == GraphIteratorType.NODE:
+            list_of_iterator = list(G.nodes)
+        elif iterator == GraphIteratorType.EDGE:
+            list_of_iterator = list(G.edges)
+        elif iterator == GraphIteratorType.ISOLATE:
+            list_of_iterator = list(nx.isolates(G))
+        else:
+            raise ValueError(f"Invalid iterator type: {iterator}")
+
+    if not list_of_iterator:
+        return iter([])
 
-    if iterator in ["node", "edge", "isolate"]:
-        if list_of_iterator is None:
-            if iterator == "node":
-                list_of_iterator = list(G.nodes)
-            elif iterator == "edge":
-                list_of_iterator = list(G.edges)
-            elif iterator == "isolate":
-                list_of_iterator = list(nx.isolates(G))
-        num_in_chunk = max(len(list_of_iterator) // n_cores, 1)
-        return chunks(list_of_iterator, num_in_chunk)
-    else:
-        raise ValueError("Invalid iterator type.")
+    return chunks(list_of_iterator, n_cores)