Allow graph generators and conversion functions to be dispatched (networkx#6876)

* Allow graph generators and conversion functions to be dispatched

For now, the `backend` argument *must* be used to dispatch to a backend.
Global config for automatic backends *does not* work on graph generators,
readers, converters, or any function that does not have any graph inputs.

For example, `G = nx.from_pandas_edgelist(df, backend="cugraph")`

* Test dispatching of graph creation function

* oops fix

* Dispatch more graph creation (i.e. non-Graph input) functions

* Don't dispatch `to_networkx_graph`--it specifically creates a NetworkX graph and not a backend graph

Author: eriknw

networkx/algorithms/bipartite/edgelist.py

@@ -146,6 +146,7 @@ def generate_edgelist(G, delimiter=" ", data=True):
                 yield delimiter.join(map(str, edge))
 
 
+@nx._dispatch(name="bipartite_parse_edgelist", graphs=None)
 def parse_edgelist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
 ):
@@ -267,6 +268,7 @@ def parse_edgelist(
 
 
 @open_file(0, mode="rb")
+@nx._dispatch(name="bipartite_read_edgelist", graphs=None)
 def read_edgelist(
     path,
     comments="#",

networkx/algorithms/bipartite/generators.py

@@ -21,6 +21,7 @@
 
 
 @nodes_or_number([0, 1])
+@nx._dispatch(graphs=None)
 def complete_bipartite_graph(n1, n2, create_using=None):
     """Returns the complete bipartite graph `K_{n_1,n_2}`.
 
@@ -66,6 +67,7 @@ def complete_bipartite_graph(n1, n2, create_using=None):
 
 
 @py_random_state(3)
+@nx._dispatch(name="bipartite_configuration_model", graphs=None)
 def configuration_model(aseq, bseq, create_using=None, seed=None):
     """Returns a random bipartite graph from two given degree sequences.
 
@@ -136,6 +138,7 @@ def configuration_model(aseq, bseq, create_using=None, seed=None):
     return G
 
 
+@nx._dispatch(name="bipartite_havel_hakimi_graph", graphs=None)
 def havel_hakimi_graph(aseq, bseq, create_using=None):
     """Returns a bipartite graph from two given degree sequences using a
     Havel-Hakimi style construction.
@@ -210,6 +213,7 @@ def havel_hakimi_graph(aseq, bseq, create_using=None):
     return G
 
 
+@nx._dispatch(graphs=None)
 def reverse_havel_hakimi_graph(aseq, bseq, create_using=None):
     """Returns a bipartite graph from two given degree sequences using a
     Havel-Hakimi style construction.
@@ -283,6 +287,7 @@ def reverse_havel_hakimi_graph(aseq, bseq, create_using=None):
     return G
 
 
+@nx._dispatch(graphs=None)
 def alternating_havel_hakimi_graph(aseq, bseq, create_using=None):
     """Returns a bipartite graph from two given degree sequences using
     an alternating Havel-Hakimi style construction.
@@ -361,6 +366,7 @@ def alternating_havel_hakimi_graph(aseq, bseq, create_using=None):
 
 
 @py_random_state(3)
+@nx._dispatch(graphs=None)
 def preferential_attachment_graph(aseq, p, create_using=None, seed=None):
     """Create a bipartite graph with a preferential attachment model from
     a given single degree sequence.
@@ -432,6 +438,7 @@ def preferential_attachment_graph(aseq, p, create_using=None, seed=None):
 
 
 @py_random_state(3)
+@nx._dispatch(graphs=None)
 def random_graph(n, m, p, seed=None, directed=False):
     """Returns a bipartite random graph.
 
@@ -518,6 +525,7 @@ def random_graph(n, m, p, seed=None, directed=False):
 
 
 @py_random_state(3)
+@nx._dispatch(graphs=None)
 def gnmk_random_graph(n, m, k, seed=None, directed=False):
     """Returns a random bipartite graph G_{n,m,k}.
 

networkx/algorithms/bipartite/matrix.py

@@ -110,6 +110,7 @@ def biadjacency_matrix(
         raise nx.NetworkXError(f"Unknown sparse array format: {format}") from err
 
 
+@nx._dispatch(graphs=None)
 def from_biadjacency_matrix(A, create_using=None, edge_attribute="weight"):
     r"""Creates a new bipartite graph from a biadjacency matrix given as a
     SciPy sparse array.

networkx/algorithms/community/label_propagation.py

@@ -13,8 +13,8 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
 @py_random_state("seed")
+@nx._dispatch(edge_attrs="weight")
 def fast_label_propagation_communities(G, *, weight=None, seed=None):
     """Returns communities in `G` as detected by fast label propagation.
 

networkx/algorithms/core.py

@@ -142,7 +142,7 @@ def _core_subgraph(G, k_filter, k=None, core=None):
     return G.subgraph(nodes).copy()
 
 
-@nx._dispatch
+@nx._dispatch(preserve_all_attrs=True)
 def k_core(G, k=None, core_number=None):
     """Returns the k-core of G.
 
@@ -195,7 +195,7 @@ def k_filter(v, k, c):
     return _core_subgraph(G, k_filter, k, core_number)
 
 
-@nx._dispatch
+@nx._dispatch(preserve_all_attrs=True)
 def k_shell(G, k=None, core_number=None):
     """Returns the k-shell of G.
 
@@ -255,6 +255,7 @@ def k_filter(v, k, c):
     return _core_subgraph(G, k_filter, k, core_number)
 
 
+@nx._dispatch(preserve_all_attrs=True)
 def k_crust(G, k=None, core_number=None):
     """Returns the k-crust of G.
 
@@ -314,7 +315,7 @@ def k_crust(G, k=None, core_number=None):
     return G.subgraph(nodes).copy()
 
 
-@nx._dispatch
+@nx._dispatch(preserve_all_attrs=True)
 def k_corona(G, k, core_number=None):
     """Returns the k-corona of G.
 
@@ -371,7 +372,7 @@ def func(v, k, c):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatch(preserve_all_attrs=True)
 def k_truss(G, k):
     """Returns the k-truss of `G`.
 

networkx/algorithms/graphical.py

@@ -14,6 +14,7 @@
 ]
 
 
+@nx._dispatch(graphs=None)
 def is_graphical(sequence, method="eg"):
     """Returns True if sequence is a valid degree sequence.
 
@@ -92,6 +93,7 @@ def _basic_graphical_tests(deg_sequence):
     return dmax, dmin, dsum, n, num_degs
 
 
+@nx._dispatch(graphs=None)
 def is_valid_degree_sequence_havel_hakimi(deg_sequence):
     r"""Returns True if deg_sequence can be realized by a simple graph.
 
@@ -181,6 +183,7 @@ def is_valid_degree_sequence_havel_hakimi(deg_sequence):
     return True
 
 
+@nx._dispatch(graphs=None)
 def is_valid_degree_sequence_erdos_gallai(deg_sequence):
     r"""Returns True if deg_sequence can be realized by a simple graph.
 
@@ -271,6 +274,7 @@ def is_valid_degree_sequence_erdos_gallai(deg_sequence):
     return True
 
 
+@nx._dispatch(graphs=None)
 def is_multigraphical(sequence):
     """Returns True if some multigraph can realize the sequence.
 
@@ -321,6 +325,7 @@ def is_multigraphical(sequence):
     return True
 
 
+@nx._dispatch(graphs=None)
 def is_pseudographical(sequence):
     """Returns True if some pseudograph can realize the sequence.
 
@@ -367,6 +372,7 @@ def is_pseudographical(sequence):
     return sum(deg_sequence) % 2 == 0 and min(deg_sequence) >= 0
 
 
+@nx._dispatch(graphs=None)
 def is_digraphical(in_sequence, out_sequence):
     r"""Returns True if some directed graph can realize the in- and out-degree
     sequences.

networkx/algorithms/shortest_paths/dense.py

@@ -167,6 +167,7 @@ def floyd_warshall_predecessor_and_distance(G, weight="weight"):
     return dict(pred), dict(dist)
 
 
+@nx._dispatch(graphs=None)
 def reconstruct_path(source, target, predecessors):
     """Reconstruct a path from source to target using the predecessors
     dict as returned by floyd_warshall_predecessor_and_distance

networkx/algorithms/threshold.py

@@ -301,6 +301,7 @@ def weights_to_creation_sequence(
 
 
 # Manipulating NetworkX.Graphs in context of threshold graphs
+@nx._dispatch(graphs=None)
 def threshold_graph(creation_sequence, create_using=None):
     """
     Create a threshold graph from the creation sequence or compact

networkx/algorithms/tournament.py

@@ -151,6 +151,7 @@ def hamiltonian_path(G):
 
 
 @py_random_state(1)
+@nx._dispatch(graphs=None)
 def random_tournament(n, seed=None):
     r"""Returns a random tournament graph on `n` nodes.
 

networkx/algorithms/tree/coding.py

@@ -128,6 +128,7 @@ def _make_tuple(T, root, _parent):
     return _make_tuple(T, root, None)
 
 
+@nx._dispatch(graphs=None)
 def from_nested_tuple(sequence, sensible_relabeling=False):
     """Returns the rooted tree corresponding to the given nested tuple.
 
@@ -313,6 +314,7 @@ def parents(u):
     return result
 
 
+@nx._dispatch(graphs=None)
 def from_prufer_sequence(sequence):
     r"""Returns the tree corresponding to the given Prüfer sequence.