From 9cc8b422a512e7e7819238d597fd6815ec9c1c8e Mon Sep 17 00:00:00 2001
From: peijenburg <mas8berg@gmail.com>
Date: Sat, 9 Dec 2023 23:49:55 +0100
Subject: [PATCH 001/129] Add Kirchhoff index / Effective graph resistance
 (#6926)

* Add Kirchhoff index

Add the computation of the Kirchhoff index to networkx

* minor fixes

* scipy not necessary

* scipy not necessary

* style fixes

* small doc change

* change digraph, add test

* vectorise final computation

* style fix

* minor cleanup tests

* Add Kirchhoff index

Add the computation of the Kirchhoff index to networkx

* minor fixes

* scipy not necessary

* scipy not necessary

* style fixes

* small doc change

* change digraph, add test

* vectorise final computation

* style fix

* minor cleanup tests

* fix

* change name

* remove return var
---
 .../algorithms/distance_measures.rst          |  1 +
 networkx/algorithms/distance_measures.py      | 93 ++++++++++++++++++-
 .../tests/test_distance_measures.py           | 85 +++++++++++++++++
 3 files changed, 177 insertions(+), 2 deletions(-)

diff --git a/doc/reference/algorithms/distance_measures.rst b/doc/reference/algorithms/distance_measures.rst
index cd54a4afa49..172e5b6ddb8 100644
--- a/doc/reference/algorithms/distance_measures.rst
+++ b/doc/reference/algorithms/distance_measures.rst
@@ -10,6 +10,7 @@ Distance Measures
    center
    diameter
    eccentricity
+   effective_graph_resistance
    kemeny_constant
    periphery
    radius
diff --git a/networkx/algorithms/distance_measures.py b/networkx/algorithms/distance_measures.py
index 09bde0cc157..04f88b17b6a 100644
--- a/networkx/algorithms/distance_measures.py
+++ b/networkx/algorithms/distance_measures.py
@@ -12,6 +12,7 @@
     "barycenter",
     "resistance_distance",
     "kemeny_constant",
+    "effective_graph_resistance",
 ]
 
 
@@ -634,7 +635,7 @@ def barycenter(G, weight=None, attr=None, sp=None):
 @not_implemented_for("directed")
 @nx._dispatch(edge_attrs="weight")
 def resistance_distance(G, nodeA=None, nodeB=None, weight=None, invert_weight=True):
-    """Returns the resistance distance between every pair of nodes on graph G.
+    """Returns the resistance distance between pairs of nodes in graph G.
 
     The resistance distance between two nodes of a graph is akin to treating
     the graph as a grid of resistors with a resistance equal to the provided
@@ -763,6 +764,94 @@ def resistance_distance(G, nodeA=None, nodeB=None, weight=None, invert_weight=Tr
         return d
 
 
+@not_implemented_for("directed")
+@nx._dispatch(edge_attrs="weight")
+def effective_graph_resistance(G, weight=None, invert_weight=True):
+    """Returns the Effective graph resistance of G.
+
+    Also known as the Kirchhoff index.
+
+    The effective graph resistance is defined as the sum
+    of the resistance distance of every node pair in G [1]_.
+
+    If weight is not provided, then a weight of 1 is used for all edges.
+
+    The effective graph resistance of a disconnected graph is infinite.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       A graph
+
+    weight : string or None, optional (default=None)
+       The edge data key used to compute the effective graph resistance.
+       If None, then each edge has weight 1.
+
+    invert_weight : boolean (default=True)
+        Proper calculation of resistance distance requires building the
+        Laplacian matrix with the reciprocal of the weight. Not required
+        if the weight is already inverted. Weight cannot be zero.
+
+    Returns
+    -------
+    RG : float
+        The effective graph resistance of `G`.
+
+    Raises
+    -------
+    NetworkXNotImplemented
+        If `G` is a directed graph.
+
+    NetworkXError
+        If `G` does not contain any nodes.
+
+    Examples
+    --------
+    >>> G = nx.Graph([(1, 2), (1, 3), (1, 4), (3, 4), (3, 5), (4, 5)])
+    >>> round(nx.effective_graph_resistance(G), 10)
+    10.25
+
+    Notes
+    -----
+    The implementation is based on Theorem 2.2 in [2]_. Self-loops are ignored.
+    Multi-edges are contracted in one edge with weight equal to the harmonic sum of the weights.
+
+    References
+    ----------
+    .. [1] Wolfram
+       "Kirchhoff Index."
+       https://mathworld.wolfram.com/KirchhoffIndex.html
+    .. [2] W. Ellens, F. M. Spieksma, P. Van Mieghem, A. Jamakovic, R. E. Kooij.
+        Effective graph resistance.
+        Lin. Alg. Appl. 435:2491-2506, 2011.
+    """
+    import numpy as np
+
+    if len(G) == 0:
+        raise nx.NetworkXError("Graph G must contain at least one node.")
+
+    # Disconnected graphs have infinite Effective graph resistance
+    if not nx.is_connected(G):
+        return np.inf
+
+    # Invert weights
+    G = G.copy()
+    if invert_weight and weight is not None:
+        if G.is_multigraph():
+            for u, v, k, d in G.edges(keys=True, data=True):
+                d[weight] = 1 / d[weight]
+        else:
+            for u, v, d in G.edges(data=True):
+                d[weight] = 1 / d[weight]
+
+    # Get Laplacian eigenvalues
+    mu = np.sort(nx.laplacian_spectrum(G, weight=weight))
+
+    # Compute Effective graph resistance based on spectrum of the Laplacian
+    # Self-loops are ignored
+    return np.sum(1 / mu[1:]) * G.number_of_nodes()
+
+
 @nx.utils.not_implemented_for("directed")
 @nx._dispatch(edge_attrs="weight")
 def kemeny_constant(G, *, weight=None):
@@ -793,7 +882,7 @@ def kemeny_constant(G, *, weight=None):
 
     Returns
     -------
-    K : float
+    float
         The Kemeny constant of the graph `G`.
 
     Raises
diff --git a/networkx/algorithms/tests/test_distance_measures.py b/networkx/algorithms/tests/test_distance_measures.py
index d4b5cf2f119..5cfe2cc9cae 100644
--- a/networkx/algorithms/tests/test_distance_measures.py
+++ b/networkx/algorithms/tests/test_distance_measures.py
@@ -423,6 +423,91 @@ def test_resistance_distance_all(self):
         assert round(rd[1][3], 5) == 1
 
 
+class TestEffectiveGraphResistance:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+
+    def setup_method(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=2)
+        G.add_edge(1, 3, weight=1)
+        G.add_edge(2, 3, weight=4)
+        self.G = G
+
+    def test_effective_graph_resistance_directed_graph(self):
+        G = nx.DiGraph()
+        with pytest.raises(nx.NetworkXNotImplemented):
+            nx.effective_graph_resistance(G)
+
+    def test_effective_graph_resistance_empty(self):
+        G = nx.Graph()
+        with pytest.raises(nx.NetworkXError):
+            nx.effective_graph_resistance(G)
+
+    def test_effective_graph_resistance_not_connected(self):
+        G = nx.Graph([(1, 2), (3, 4)])
+        RG = nx.effective_graph_resistance(G)
+        assert np.isinf(RG)
+
+    def test_effective_graph_resistance(self):
+        RG = nx.effective_graph_resistance(self.G, "weight", True)
+        rd12 = 1 / (1 / (1 + 4) + 1 / 2)
+        rd13 = 1 / (1 / (1 + 2) + 1 / 4)
+        rd23 = 1 / (1 / (2 + 4) + 1 / 1)
+        assert np.isclose(RG, rd12 + rd13 + rd23)
+
+    def test_effective_graph_resistance_noinv(self):
+        RG = nx.effective_graph_resistance(self.G, "weight", False)
+        rd12 = 1 / (1 / (1 / 1 + 1 / 4) + 1 / (1 / 2))
+        rd13 = 1 / (1 / (1 / 1 + 1 / 2) + 1 / (1 / 4))
+        rd23 = 1 / (1 / (1 / 2 + 1 / 4) + 1 / (1 / 1))
+        assert np.isclose(RG, rd12 + rd13 + rd23)
+
+    def test_effective_graph_resistance_no_weight(self):
+        RG = nx.effective_graph_resistance(self.G)
+        assert np.isclose(RG, 2)
+
+    def test_effective_graph_resistance_neg_weight(self):
+        self.G[2][3]["weight"] = -4
+        RG = nx.effective_graph_resistance(self.G, "weight", True)
+        rd12 = 1 / (1 / (1 + -4) + 1 / 2)
+        rd13 = 1 / (1 / (1 + 2) + 1 / (-4))
+        rd23 = 1 / (1 / (2 + -4) + 1 / 1)
+        assert np.isclose(RG, rd12 + rd13 + rd23)
+
+    def test_effective_graph_resistance_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge(1, 2, weight=2)
+        G.add_edge(1, 3, weight=1)
+        G.add_edge(2, 3, weight=1)
+        G.add_edge(2, 3, weight=3)
+        RG = nx.effective_graph_resistance(G, "weight", True)
+        edge23 = 1 / (1 / 1 + 1 / 3)
+        rd12 = 1 / (1 / (1 + edge23) + 1 / 2)
+        rd13 = 1 / (1 / (1 + 2) + 1 / edge23)
+        rd23 = 1 / (1 / (2 + edge23) + 1 / 1)
+        assert np.isclose(RG, rd12 + rd13 + rd23)
+
+    def test_effective_graph_resistance_div0(self):
+        with pytest.raises(ZeroDivisionError):
+            self.G[1][2]["weight"] = 0
+            nx.effective_graph_resistance(self.G, "weight")
+
+    def test_effective_graph_resistance_complete_graph(self):
+        N = 10
+        G = nx.complete_graph(N)
+        RG = nx.effective_graph_resistance(G)
+        assert np.isclose(RG, N - 1)
+
+    def test_effective_graph_resistance_path_graph(self):
+        N = 10
+        G = nx.path_graph(N)
+        RG = nx.effective_graph_resistance(G)
+        assert np.isclose(RG, (N - 1) * N * (N + 1) // 6)
+
+
 class TestBarycenter:
     """Test :func:`networkx.algorithms.distance_measures.barycenter`."""
 

From d85f3a49d99fc439a1d01f8cb1b1bfb1062d4874 Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Tue, 12 Dec 2023 23:17:35 +0400
Subject: [PATCH 002/129] DOC: fix URL econded links and doc references (#7152)

---
 doc/reference/algorithms/dag.rst | 1 +
 networkx/algorithms/cycles.py    | 2 +-
 networkx/algorithms/dag.py       | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/doc/reference/algorithms/dag.rst b/doc/reference/algorithms/dag.rst
index f1cadf8afef..8fb911788f3 100644
--- a/doc/reference/algorithms/dag.rst
+++ b/doc/reference/algorithms/dag.rst
@@ -21,3 +21,4 @@ Directed Acyclic Graphs
    dag_longest_path
    dag_longest_path_length
    dag_to_branching
+   compute_v_structures
diff --git a/networkx/algorithms/cycles.py b/networkx/algorithms/cycles.py
index 9149e9eb10d..5221ca15893 100644
--- a/networkx/algorithms/cycles.py
+++ b/networkx/algorithms/cycles.py
@@ -1202,7 +1202,7 @@ def girth(G):
 
     References
     ----------
-    .. [1] https://en.wikipedia.org/wiki/Girth_(graph_theory)
+    .. [1] `Wikipedia: Girth <https://en.wikipedia.org/wiki/Girth_(graph_theory)>`_
 
     """
     girth = depth_limit = inf
diff --git a/networkx/algorithms/dag.py b/networkx/algorithms/dag.py
index fb74df81c6d..58138c340c4 100644
--- a/networkx/algorithms/dag.py
+++ b/networkx/algorithms/dag.py
@@ -1249,7 +1249,7 @@ def compute_v_structures(G):
 
     Notes
     -----
-    https://en.wikipedia.org/wiki/Collider_(statistics)
+    `Wikipedia: Collider in causal graphs <https://en.wikipedia.org/wiki/Collider_(statistics)>`_
     """
     for collider, preds in G.pred.items():
         for common_parents in combinations(preds, r=2):

From dd6d68e27bd8cc626c17e7e8e3231a972c171460 Mon Sep 17 00:00:00 2001
From: Navya Agarwal <82928853+navyagarwal@users.noreply.github.com>
Date: Wed, 13 Dec 2023 18:34:26 +0530
Subject: [PATCH 003/129] Changed return types of shortest path methods to
 improve consistency (#6584)

* Fixed return types and modified tests

* Resolved check failures in centrality\reaching.py

* Fixed doc_str examples

* Minor edit
---
 networkx/algorithms/centrality/reaching.py           |  2 +-
 networkx/algorithms/shortest_paths/generic.py        |  8 ++++----
 .../algorithms/shortest_paths/tests/test_generic.py  | 12 ++++++------
 .../shortest_paths/tests/test_unweighted.py          |  4 ++--
 networkx/algorithms/shortest_paths/unweighted.py     |  4 ++--
 5 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/networkx/algorithms/centrality/reaching.py b/networkx/algorithms/centrality/reaching.py
index 7b9eac564ac..e93c8e6d8cd 100644
--- a/networkx/algorithms/centrality/reaching.py
+++ b/networkx/algorithms/centrality/reaching.py
@@ -112,7 +112,7 @@ def as_distance(u, v, d):
     # TODO This can be trivially parallelized.
     lrc = [
         centrality(G, node, paths=paths, weight=weight, normalized=normalized)
-        for node, paths in shortest_paths.items()
+        for node, paths in shortest_paths
     ]
 
     max_lrc = max(lrc)
diff --git a/networkx/algorithms/shortest_paths/generic.py b/networkx/algorithms/shortest_paths/generic.py
index e47c4b4f5a1..0d1bb5795f9 100644
--- a/networkx/algorithms/shortest_paths/generic.py
+++ b/networkx/algorithms/shortest_paths/generic.py
@@ -111,7 +111,7 @@ def shortest_path(G, source=None, target=None, weight=None, method="dijkstra"):
     >>> p = nx.shortest_path(G, target=4)  # source not specified
     >>> p[1] # shortest path from source=1 to target=4
     [1, 2, 3, 4]
-    >>> p = nx.shortest_path(G)  # source, target not specified
+    >>> p = dict(nx.shortest_path(G))  # source, target not specified
     >>> p[2][4] # shortest path from source=2 to target=4
     [2, 3, 4]
 
@@ -140,11 +140,11 @@ def shortest_path(G, source=None, target=None, weight=None, method="dijkstra"):
 
             # Find paths between all pairs.
             if method == "unweighted":
-                paths = dict(nx.all_pairs_shortest_path(G))
+                paths = nx.all_pairs_shortest_path(G)
             elif method == "dijkstra":
-                paths = dict(nx.all_pairs_dijkstra_path(G, weight=weight))
+                paths = nx.all_pairs_dijkstra_path(G, weight=weight)
             else:  # method == 'bellman-ford':
-                paths = dict(nx.all_pairs_bellman_ford_path(G, weight=weight))
+                paths = nx.all_pairs_bellman_ford_path(G, weight=weight)
         else:
             # Find paths from all nodes co-accessible to the target.
             if G.is_directed():
diff --git a/networkx/algorithms/shortest_paths/tests/test_generic.py b/networkx/algorithms/shortest_paths/tests/test_generic.py
index 863f1dcb947..9fcc8c396d5 100644
--- a/networkx/algorithms/shortest_paths/tests/test_generic.py
+++ b/networkx/algorithms/shortest_paths/tests/test_generic.py
@@ -212,22 +212,22 @@ def test_single_source_all_shortest_paths(self):
         assert sorted(ans[4]) == [[4]]
 
     def test_all_pairs_shortest_path(self):
-        p = nx.shortest_path(self.cycle)
+        p = dict(nx.shortest_path(self.cycle))
         assert p[0][3] == [0, 1, 2, 3]
         assert p == dict(nx.all_pairs_shortest_path(self.cycle))
-        p = nx.shortest_path(self.grid)
+        p = dict(nx.shortest_path(self.grid))
         validate_grid_path(4, 4, 1, 12, p[1][12])
         # now with weights
-        p = nx.shortest_path(self.cycle, weight="weight")
+        p = dict(nx.shortest_path(self.cycle, weight="weight"))
         assert p[0][3] == [0, 1, 2, 3]
         assert p == dict(nx.all_pairs_dijkstra_path(self.cycle))
-        p = nx.shortest_path(self.grid, weight="weight")
+        p = dict(nx.shortest_path(self.grid, weight="weight"))
         validate_grid_path(4, 4, 1, 12, p[1][12])
         # weights and method specified
-        p = nx.shortest_path(self.cycle, weight="weight", method="dijkstra")
+        p = dict(nx.shortest_path(self.cycle, weight="weight", method="dijkstra"))
         assert p[0][3] == [0, 1, 2, 3]
         assert p == dict(nx.all_pairs_dijkstra_path(self.cycle))
-        p = nx.shortest_path(self.cycle, weight="weight", method="bellman-ford")
+        p = dict(nx.shortest_path(self.cycle, weight="weight", method="bellman-ford"))
         assert p[0][3] == [0, 1, 2, 3]
         assert p == dict(nx.all_pairs_bellman_ford_path(self.cycle))
 
diff --git a/networkx/algorithms/shortest_paths/tests/test_unweighted.py b/networkx/algorithms/shortest_paths/tests/test_unweighted.py
index e2d999518a5..ec0b3f757ed 100644
--- a/networkx/algorithms/shortest_paths/tests/test_unweighted.py
+++ b/networkx/algorithms/shortest_paths/tests/test_unweighted.py
@@ -92,9 +92,9 @@ def test_single_target_shortest_path(self):
     def test_single_target_shortest_path_length(self):
         pl = nx.single_target_shortest_path_length
         lengths = {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
-        assert dict(pl(self.cycle, 0)) == lengths
+        assert pl(self.cycle, 0) == lengths
         lengths = {0: 0, 1: 6, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1}
-        assert dict(pl(self.directed_cycle, 0)) == lengths
+        assert pl(self.directed_cycle, 0) == lengths
         # test missing targets
         target = 8
         with pytest.raises(nx.NodeNotFound, match=f"Target {target} is not in G"):
diff --git a/networkx/algorithms/shortest_paths/unweighted.py b/networkx/algorithms/shortest_paths/unweighted.py
index 1503ba74784..78df41bc389 100644
--- a/networkx/algorithms/shortest_paths/unweighted.py
+++ b/networkx/algorithms/shortest_paths/unweighted.py
@@ -117,7 +117,7 @@ def single_target_shortest_path_length(G, target, cutoff=None):
     Examples
     --------
     >>> G = nx.path_graph(5, create_using=nx.DiGraph())
-    >>> length = dict(nx.single_target_shortest_path_length(G, 4))
+    >>> length = nx.single_target_shortest_path_length(G, 4)
     >>> length[0]
     4
     >>> for node in range(5):
@@ -145,7 +145,7 @@ def single_target_shortest_path_length(G, target, cutoff=None):
     nextlevel = [target]
     # for version 3.3 we will return a dict like this:
     # return dict(_single_shortest_path_length(adj, nextlevel, cutoff))
-    return _single_shortest_path_length(adj, nextlevel, cutoff)
+    return dict(_single_shortest_path_length(adj, nextlevel, cutoff))
 
 
 @nx._dispatch

From 7abde0036e55539dc3e92d152728fb155c1b0139 Mon Sep 17 00:00:00 2001
From: Robert <44594743+ImHereForTheCookies@users.noreply.github.com>
Date: Wed, 13 Dec 2023 08:56:26 -0800
Subject: [PATCH 004/129] adding test coverage for isomorphism when using
 digraphs (#6417)

Co-authored-by: Mridul Seth <mail@mriduls.com>
Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 networkx/algorithms/isomorphism/tests/test_isomorphism.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/networkx/algorithms/isomorphism/tests/test_isomorphism.py b/networkx/algorithms/isomorphism/tests/test_isomorphism.py
index c669040390d..548af808ffd 100644
--- a/networkx/algorithms/isomorphism/tests/test_isomorphism.py
+++ b/networkx/algorithms/isomorphism/tests/test_isomorphism.py
@@ -1,3 +1,5 @@
+import pytest
+
 import networkx as nx
 from networkx.algorithms import isomorphism as iso
 
@@ -38,3 +40,9 @@ def test_faster_could_be_isomorphic(self):
     def test_is_isomorphic(self):
         assert iso.is_isomorphic(self.G1, self.G2)
         assert not iso.is_isomorphic(self.G1, self.G4)
+        assert iso.is_isomorphic(self.G1.to_directed(), self.G2.to_directed())
+        assert not iso.is_isomorphic(self.G1.to_directed(), self.G4.to_directed())
+        with pytest.raises(
+            nx.NetworkXError, match="Graphs G1 and G2 are not of the same type."
+        ):
+            iso.is_isomorphic(self.G1.to_directed(), self.G1)

From 1dade0d07ec0818bcdddd76f43fcca7d74a8649e Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Wed, 13 Dec 2023 11:54:59 -0600
Subject: [PATCH 005/129] Remove usage of `__networkx_plugin__` (use
 `__networkx_backend__` instead) (#7157)

Backends should have had enough time to update by now.
---
 networkx/utils/backends.py | 45 +++++++-------------------------------
 1 file changed, 8 insertions(+), 37 deletions(-)

diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 4ecd1b13bd3..c2d5661e034 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -463,46 +463,29 @@ def __call__(self, /, *args, backend=None, **kwargs):
                     args[self.graphs[gname]] = val
 
             has_backends = any(
-                hasattr(g, "__networkx_backend__") or hasattr(g, "__networkx_plugin__")
+                hasattr(g, "__networkx_backend__")
                 if gname not in self.list_graphs
-                else any(
-                    hasattr(g2, "__networkx_backend__")
-                    or hasattr(g2, "__networkx_plugin__")
-                    for g2 in g
-                )
+                else any(hasattr(g2, "__networkx_backend__") for g2 in g)
                 for gname, g in graphs_resolved.items()
             )
             if has_backends:
                 graph_backend_names = {
-                    getattr(
-                        g,
-                        "__networkx_backend__",
-                        getattr(g, "__networkx_plugin__", "networkx"),
-                    )
+                    getattr(g, "__networkx_backend__", "networkx")
                     for gname, g in graphs_resolved.items()
                     if gname not in self.list_graphs
                 }
                 for gname in self.list_graphs & graphs_resolved.keys():
                     graph_backend_names.update(
-                        getattr(
-                            g,
-                            "__networkx_backend__",
-                            getattr(g, "__networkx_plugin__", "networkx"),
-                        )
+                        getattr(g, "__networkx_backend__", "networkx")
                         for g in graphs_resolved[gname]
                     )
         else:
             has_backends = any(
-                hasattr(g, "__networkx_backend__") or hasattr(g, "__networkx_plugin__")
-                for g in graphs_resolved.values()
+                hasattr(g, "__networkx_backend__") for g in graphs_resolved.values()
             )
             if has_backends:
                 graph_backend_names = {
-                    getattr(
-                        g,
-                        "__networkx_backend__",
-                        getattr(g, "__networkx_plugin__", "networkx"),
-                    )
+                    getattr(g, "__networkx_backend__", "networkx")
                     for g in graphs_resolved.values()
                 }
         if has_backends:
@@ -740,12 +723,7 @@ def _convert_arguments(self, backend_name, args, kwargs):
                         name=self.name,
                         graph_name=gname,
                     )
-                    if getattr(
-                        g,
-                        "__networkx_backend__",
-                        getattr(g, "__networkx_plugin__", "networkx"),
-                    )
-                    == "networkx"
+                    if getattr(g, "__networkx_backend__", "networkx") == "networkx"
                     else g
                     for g in bound.arguments[gname]
                 ]
@@ -773,14 +751,7 @@ def _convert_arguments(self, backend_name, args, kwargs):
                     preserve_graph = gname in preserve_graph_attrs
                 else:
                     preserve_graph = preserve_graph_attrs
-                if (
-                    getattr(
-                        graph,
-                        "__networkx_backend__",
-                        getattr(graph, "__networkx_plugin__", "networkx"),
-                    )
-                    == "networkx"
-                ):
+                if getattr(graph, "__networkx_backend__", "networkx") == "networkx":
                     bound.arguments[gname] = backend.convert_from_nx(
                         graph,
                         edge_attrs=edges,

From 1c2fa4b9372df1a1428444d89fe6a72359e1a2cb Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Fri, 15 Dec 2023 08:28:28 +0400
Subject: [PATCH 006/129]  DOC: consistent spelling of neighbor and rename vars
  (#7162)

* DOC: consistent spelling of neighbor and rename vars

* rename more vars
---
 .../algorithms/approximation/treewidth.py     |  8 ++---
 .../algorithms/centrality/voterank_alg.py     |  2 +-
 networkx/algorithms/cluster.py                | 10 +++---
 .../algorithms/coloring/greedy_coloring.py    |  8 ++---
 .../coloring/tests/test_coloring.py           |  6 ++--
 networkx/algorithms/community/asyn_fluid.py   |  4 +--
 .../algorithms/community/label_propagation.py |  2 +-
 networkx/algorithms/community/louvain.py      |  4 +--
 networkx/algorithms/core.py                   |  2 +-
 networkx/algorithms/dominating.py             |  6 ++--
 networkx/algorithms/graph_hashing.py          |  6 ++--
 networkx/algorithms/isomorphism/ismags.py     |  8 ++---
 networkx/algorithms/isomorphism/vf2pp.py      |  8 ++---
 networkx/algorithms/matching.py               | 10 +++---
 networkx/algorithms/planar_drawing.py         | 14 ++++----
 networkx/algorithms/similarity.py             | 14 ++++----
 networkx/algorithms/sparsifiers.py            | 18 +++++-----
 networkx/algorithms/summarization.py          | 36 +++++++++----------
 networkx/algorithms/tests/test_mis.py         |  4 +--
 networkx/classes/graph.py                     |  4 +--
 networkx/generators/duplication.py            |  4 +--
 networkx/generators/line.py                   |  6 ++--
 networkx/generators/random_graphs.py          |  8 ++---
 23 files changed, 95 insertions(+), 97 deletions(-)

diff --git a/networkx/algorithms/approximation/treewidth.py b/networkx/algorithms/approximation/treewidth.py
index ce673b6eda4..89ac39ce67d 100644
--- a/networkx/algorithms/approximation/treewidth.py
+++ b/networkx/algorithms/approximation/treewidth.py
@@ -70,7 +70,7 @@ def treewidth_min_fill_in(G):
     """Returns a treewidth decomposition using the Minimum Fill-in heuristic.
 
     The heuristic chooses a node from the graph, where the number of edges
-    added turning the neighbourhood of the chosen node into clique is as
+    added turning the neighborhood of the chosen node into clique is as
     small as possible.
 
     Parameters
@@ -89,7 +89,7 @@ class MinDegreeHeuristic:
     """Implements the Minimum Degree heuristic.
 
     The heuristic chooses the nodes according to their degree
-    (number of neighbours), i.e., first the node with the lowest degree is
+    (number of neighbors), i.e., first the node with the lowest degree is
     chosen, then the graph is updated and the corresponding node is
     removed. Next, a new node with the lowest degree is chosen, and so on.
     """
@@ -136,7 +136,7 @@ def min_fill_in_heuristic(graph):
     """Implements the Minimum Degree heuristic.
 
     Returns the node from the graph, where the number of edges added when
-    turning the neighbourhood of the chosen node into clique is as small as
+    turning the neighborhood of the chosen node into clique is as small as
     possible. This algorithm chooses the nodes using the Minimum Fill-In
     heuristic. The running time of the algorithm is :math:`O(V^3)` and it uses
     additional constant memory."""
@@ -201,7 +201,7 @@ def treewidth_decomp(G, heuristic=min_fill_in_heuristic):
     # get first node from heuristic
     elim_node = heuristic(graph)
     while elim_node is not None:
-        # connect all neighbours with each other
+        # connect all neighbors with each other
         nbrs = graph[elim_node]
         for u, v in itertools.permutations(nbrs, 2):
             if v not in graph[u]:
diff --git a/networkx/algorithms/centrality/voterank_alg.py b/networkx/algorithms/centrality/voterank_alg.py
index f9cf43c7813..ca6bd913479 100644
--- a/networkx/algorithms/centrality/voterank_alg.py
+++ b/networkx/algorithms/centrality/voterank_alg.py
@@ -9,7 +9,7 @@ def voterank(G, number_of_nodes=None):
     """Select a list of influential nodes in a graph using VoteRank algorithm
 
     VoteRank [1]_ computes a ranking of the nodes in a graph G based on a
-    voting scheme. With VoteRank, all nodes vote for each of its in-neighbours
+    voting scheme. With VoteRank, all nodes vote for each of its in-neighbors
     and the node with the highest votes is elected iteratively. The voting
     ability of out-neighbors of elected nodes is decreased in subsequent turns.
 
diff --git a/networkx/algorithms/cluster.py b/networkx/algorithms/cluster.py
index 0500852a7ce..4297d5c2862 100644
--- a/networkx/algorithms/cluster.py
+++ b/networkx/algorithms/cluster.py
@@ -67,20 +67,18 @@ def triangles(G, nodes=None):
 
     # dict used to avoid visiting the same nodes twice
     # this allows calculating/counting each triangle only once
-    later_neighbors = {}
+    later_nbrs = {}
 
     # iterate over the nodes in a graph
     for node, neighbors in G.adjacency():
-        later_neighbors[node] = {
-            n for n in neighbors if n not in later_neighbors and n != node
-        }
+        later_nbrs[node] = {n for n in neighbors if n not in later_nbrs and n != node}
 
     # instantiate Counter for each node to include isolated nodes
     # add 1 to the count if a nodes neighbor's neighbor is also a neighbor
     triangle_counts = Counter(dict.fromkeys(G, 0))
-    for node1, neighbors in later_neighbors.items():
+    for node1, neighbors in later_nbrs.items():
         for node2 in neighbors:
-            third_nodes = neighbors & later_neighbors[node2]
+            third_nodes = neighbors & later_nbrs[node2]
             m = len(third_nodes)
             triangle_counts[node1] += m
             triangle_counts[node2] += m
diff --git a/networkx/algorithms/coloring/greedy_coloring.py b/networkx/algorithms/coloring/greedy_coloring.py
index bbb3ba03cef..efc70f30eb8 100644
--- a/networkx/algorithms/coloring/greedy_coloring.py
+++ b/networkx/algorithms/coloring/greedy_coloring.py
@@ -274,7 +274,7 @@ def greedy_color(G, strategy="largest_first", interchange=False):
     """Color a graph using various strategies of greedy graph coloring.
 
     Attempts to color a graph using as few colors as possible, where no
-    neighbours of a node can have same color as the node itself. The
+    neighbors of a node can have same color as the node itself. The
     given strategy determines the order in which nodes are colored.
 
     The strategies are described in [1]_, and smallest-last is based on
@@ -371,11 +371,11 @@ def greedy_color(G, strategy="largest_first", interchange=False):
     if interchange:
         return _greedy_coloring_with_interchange(G, nodes)
     for u in nodes:
-        # Set to keep track of colors of neighbours
-        neighbour_colors = {colors[v] for v in G[u] if v in colors}
+        # Set to keep track of colors of neighbors
+        nbr_colors = {colors[v] for v in G[u] if v in colors}
         # Find the first unused color.
         for color in itertools.count():
-            if color not in neighbour_colors:
+            if color not in nbr_colors:
                 break
         # Assign the new color to the current node.
         colors[u] = color
diff --git a/networkx/algorithms/coloring/tests/test_coloring.py b/networkx/algorithms/coloring/tests/test_coloring.py
index a2a4e39589e..dd2842d548a 100644
--- a/networkx/algorithms/coloring/tests/test_coloring.py
+++ b/networkx/algorithms/coloring/tests/test_coloring.py
@@ -446,13 +446,13 @@ def color_remaining_nodes(
             )
 
             for u in node_iterator:
-                # Set to keep track of colors of neighbours
-                neighbour_colors = {
+                # Set to keep track of colors of neighbors
+                nbr_colors = {
                     aux_colored_nodes[v] for v in G[u] if v in aux_colored_nodes
                 }
                 # Find the first unused color.
                 for color in itertools.count():
-                    if color not in neighbour_colors:
+                    if color not in nbr_colors:
                         break
                 aux_colored_nodes[u] = color
                 color_assignments.append((u, color))
diff --git a/networkx/algorithms/community/asyn_fluid.py b/networkx/algorithms/community/asyn_fluid.py
index 1a0029ae7ff..4c2223e6331 100644
--- a/networkx/algorithms/community/asyn_fluid.py
+++ b/networkx/algorithms/community/asyn_fluid.py
@@ -24,7 +24,7 @@ def asyn_fluidc(G, k, max_iter=100, seed=None):
     The algorithm proceeds as follows. First each of the initial k communities
     is initialized in a random vertex in the graph. Then the algorithm iterates
     over all vertices in a random order, updating the community of each vertex
-    based on its own community and the communities of its neighbours. This
+    based on its own community and the communities of its neighbors. This
     process is performed several times until convergence.
     At all times, each community has a total density of 1, which is equally
     distributed among the vertices it contains. If a vertex changes of
@@ -102,7 +102,7 @@ def asyn_fluidc(G, k, max_iter=100, seed=None):
                 com_counter.update({communities[vertex]: density[communities[vertex]]})
             except KeyError:
                 pass
-            # Gather neighbour vertex communities
+            # Gather neighbor vertex communities
             for v in G[vertex]:
                 try:
                     com_counter.update({communities[v]: density[communities[v]]})
diff --git a/networkx/algorithms/community/label_propagation.py b/networkx/algorithms/community/label_propagation.py
index c10938d627c..5d799d3de5c 100644
--- a/networkx/algorithms/community/label_propagation.py
+++ b/networkx/algorithms/community/label_propagation.py
@@ -316,7 +316,7 @@ def _most_frequent_labels(node, labeling, G):
         # accordingly, hence the immediate if statement.
         return {labeling[node]}
 
-    # Compute the frequencies of all neighbours of node
+    # Compute the frequencies of all neighbors of node
     freqs = Counter(labeling[q] for q in G[node])
     max_freq = max(freqs.values())
     return {label for label, freq in freqs.items() if freq == max_freq}
diff --git a/networkx/algorithms/community/louvain.py b/networkx/algorithms/community/louvain.py
index 772f4d79d69..6aa783d3152 100644
--- a/networkx/algorithms/community/louvain.py
+++ b/networkx/algorithms/community/louvain.py
@@ -240,7 +240,7 @@ def _one_level(G, m, partition, resolution=1, is_directed=False, seed=None):
         out_degrees = dict(G.out_degree(weight="weight"))
         Stot_in = list(in_degrees.values())
         Stot_out = list(out_degrees.values())
-        # Calculate weights for both in and out neighbours without considering self-loops
+        # Calculate weights for both in and out neighbors without considering self-loops
         nbrs = {}
         for u in G:
             nbrs[u] = defaultdict(float)
@@ -327,7 +327,7 @@ def _neighbor_weights(nbrs, node2com):
     Parameters
     ----------
     nbrs : dictionary
-           Dictionary with nodes' neighbours as keys and their edge weight as value.
+           Dictionary with nodes' neighbors as keys and their edge weight as value.
     node2com : dictionary
            Dictionary with all graph's nodes as keys and their community index as value.
 
diff --git a/networkx/algorithms/core.py b/networkx/algorithms/core.py
index 2a766ead754..87835c299d5 100644
--- a/networkx/algorithms/core.py
+++ b/networkx/algorithms/core.py
@@ -394,7 +394,7 @@ def k_corona(G, k, core_number=None):
     """Returns the k-corona of G.
 
     The k-corona is the subgraph of nodes in the k-core which have
-    exactly k neighbours in the k-core.
+    exactly k neighbors in the k-core.
 
     .. deprecated:: 3.3
        `k_corona` will not accept `MultiGraph` objects in version 3.5.
diff --git a/networkx/algorithms/dominating.py b/networkx/algorithms/dominating.py
index 97408ab4380..80276bb5a1d 100644
--- a/networkx/algorithms/dominating.py
+++ b/networkx/algorithms/dominating.py
@@ -55,13 +55,13 @@ def dominating_set(G, start_with=None):
     while remaining_nodes:
         # Choose an arbitrary node and determine its undominated neighbors.
         v = remaining_nodes.pop()
-        undominated_neighbors = set(G[v]) - dominating_set
+        undominated_nbrs = set(G[v]) - dominating_set
         # Add the node to the dominating set and the neighbors to the
         # dominated set. Finally, remove all of those nodes from the set
         # of remaining nodes.
         dominating_set.add(v)
-        dominated_nodes |= undominated_neighbors
-        remaining_nodes -= undominated_neighbors
+        dominated_nodes |= undominated_nbrs
+        remaining_nodes -= undominated_nbrs
     return dominating_set
 
 
diff --git a/networkx/algorithms/graph_hashing.py b/networkx/algorithms/graph_hashing.py
index d85a44a3604..0b69b08480c 100644
--- a/networkx/algorithms/graph_hashing.py
+++ b/networkx/algorithms/graph_hashing.py
@@ -43,7 +43,7 @@ def weisfeiler_lehman_graph_hash(
 ):
     """Return Weisfeiler Lehman (WL) graph hash.
 
-    The function iteratively aggregates and hashes neighbourhoods of each node.
+    The function iteratively aggregates and hashes neighborhoods of each node.
     After each node's neighbors are hashed to obtain updated node labels,
     a hashed histogram of resulting labels is returned as the final hash.
 
@@ -176,7 +176,7 @@ def weisfeiler_lehman_subgraph_hashes(
     additionally a hash of the initial node label (or equivalently a
     subgraph of depth 0)
 
-    The function iteratively aggregates and hashes neighbourhoods of each node.
+    The function iteratively aggregates and hashes neighborhoods of each node.
     This is achieved for each step by replacing for each node its label from
     the previous iteration with its hashed 1-hop neighborhood aggregate.
     The new node label is then appended to a list of node labels for each
@@ -254,7 +254,7 @@ def weisfeiler_lehman_subgraph_hashes(
 
     The first 2 WL subgraph hashes match. From this we can conclude that it's very
     likely the neighborhood of 4 hops around these nodes are isomorphic: each
-    iteration aggregates 1-hop neighbourhoods meaning hashes at depth $n$ are influenced
+    iteration aggregates 1-hop neighborhoods meaning hashes at depth $n$ are influenced
     by every node within $2n$ hops.
 
     However the neighborhood of 6 hops is no longer isomorphic since their 3rd hash does
diff --git a/networkx/algorithms/isomorphism/ismags.py b/networkx/algorithms/isomorphism/ismags.py
index 25ce94c87ec..1fe920adfbb 100644
--- a/networkx/algorithms/isomorphism/ismags.py
+++ b/networkx/algorithms/isomorphism/ismags.py
@@ -848,11 +848,11 @@ def _map_nodes(self, sgn, candidates, constraints, mapping=None, to_be_mapped=No
             left_to_map = to_be_mapped - set(mapping.keys())
 
             new_candidates = candidates.copy()
-            sgn_neighbours = set(self.subgraph[sgn])
-            not_gn_neighbours = set(self.graph.nodes) - set(self.graph[gn])
+            sgn_nbrs = set(self.subgraph[sgn])
+            not_gn_nbrs = set(self.graph.nodes) - set(self.graph[gn])
             for sgn2 in left_to_map:
-                if sgn2 not in sgn_neighbours:
-                    gn2_options = not_gn_neighbours
+                if sgn2 not in sgn_nbrs:
+                    gn2_options = not_gn_nbrs
                 else:
                     # Get all edges to gn of the right color:
                     g_edges = self._edges_of_same_color(sgn, sgn2)
diff --git a/networkx/algorithms/isomorphism/vf2pp.py b/networkx/algorithms/isomorphism/vf2pp.py
index 953204f669b..8cc83eb8a53 100644
--- a/networkx/algorithms/isomorphism/vf2pp.py
+++ b/networkx/algorithms/isomorphism/vf2pp.py
@@ -476,8 +476,8 @@ def _find_candidates(
     G1, G2, G1_labels, _, _, nodes_of_G2Labels, G2_nodes_of_degree = graph_params
     mapping, reverse_mapping, _, _, _, _, _, _, T2_tilde, _ = state_params
 
-    covered_neighbors = [nbr for nbr in G1[u] if nbr in mapping]
-    if not covered_neighbors:
+    covered_nbrs = [nbr for nbr in G1[u] if nbr in mapping]
+    if not covered_nbrs:
         candidates = set(nodes_of_G2Labels[G1_labels[u]])
         candidates.intersection_update(G2_nodes_of_degree[G1_degree[u]])
         candidates.intersection_update(T2_tilde)
@@ -492,10 +492,10 @@ def _find_candidates(
             )
         return candidates
 
-    nbr1 = covered_neighbors[0]
+    nbr1 = covered_nbrs[0]
     common_nodes = set(G2[mapping[nbr1]])
 
-    for nbr1 in covered_neighbors[1:]:
+    for nbr1 in covered_nbrs[1:]:
         common_nodes.intersection_update(G2[mapping[nbr1]])
 
     common_nodes.difference_update(reverse_mapping)
diff --git a/networkx/algorithms/matching.py b/networkx/algorithms/matching.py
index b20d7f6970c..f44dc9e67cd 100644
--- a/networkx/algorithms/matching.py
+++ b/networkx/algorithms/matching.py
@@ -410,7 +410,7 @@ class Blossom:
         # and w is a vertex in b.childs[wrap(i+1)].
 
         # If b is a top-level S-blossom,
-        # b.mybestedges is a list of least-slack edges to neighbouring
+        # b.mybestedges is a list of least-slack edges to neighboring
         # S-blossoms, or None if no such list has been computed yet.
         # This is used for efficient computation of delta3.
 
@@ -738,12 +738,12 @@ def _recurse(b, endstage):
                 j += jstep
                 while b.childs[j] != entrychild:
                     # Examine the vertices of the sub-blossom to see whether
-                    # it is reachable from a neighbouring S-vertex outside the
+                    # it is reachable from a neighboring S-vertex outside the
                     # expanding blossom.
                     bv = b.childs[j]
                     if label.get(bv) == 1:
                         # This sub-blossom just got label S through one of its
-                        # neighbours; leave it be.
+                        # neighbors; leave it be.
                         j += jstep
                         continue
                     if isinstance(bv, Blossom):
@@ -972,11 +972,11 @@ def verifyOptimum():
                 v = queue.pop()
                 assert label[inblossom[v]] == 1
 
-                # Scan its neighbours:
+                # Scan its neighbors:
                 for w in G.neighbors(v):
                     if w == v:
                         continue  # ignore self-loops
-                    # w is a neighbour to v
+                    # w is a neighbor to v
                     bv = inblossom[v]
                     bw = inblossom[w]
                     if bv == bw:
diff --git a/networkx/algorithms/planar_drawing.py b/networkx/algorithms/planar_drawing.py
index 47f94f17215..5c091e26e4d 100644
--- a/networkx/algorithms/planar_drawing.py
+++ b/networkx/algorithms/planar_drawing.py
@@ -78,18 +78,18 @@ def combinatorial_embedding_to_pos(embedding, fully_triangulate=False):
     left_t_child[v3] = None
 
     for k in range(3, len(node_list)):
-        vk, contour_neighbors = node_list[k]
-        wp = contour_neighbors[0]
-        wp1 = contour_neighbors[1]
-        wq = contour_neighbors[-1]
-        wq1 = contour_neighbors[-2]
-        adds_mult_tri = len(contour_neighbors) > 2
+        vk, contour_nbrs = node_list[k]
+        wp = contour_nbrs[0]
+        wp1 = contour_nbrs[1]
+        wq = contour_nbrs[-1]
+        wq1 = contour_nbrs[-2]
+        adds_mult_tri = len(contour_nbrs) > 2
 
         # Stretch gaps:
         delta_x[wp1] += 1
         delta_x[wq] += 1
 
-        delta_x_wp_wq = sum(delta_x[x] for x in contour_neighbors[1:])
+        delta_x_wp_wq = sum(delta_x[x] for x in contour_nbrs[1:])
 
         # Adjust offsets
         delta_x[vk] = (-y_coordinate[wp] + delta_x_wp_wq + y_coordinate[wq]) // 2
diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index 3d943c20d7e..92b0cf9a3e1 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -1689,22 +1689,22 @@ def generate_random_paths(
         for _ in range(path_length):
             # Randomly sample a neighbor (v_j) according
             # to transition probabilities from ``node`` (v) to its neighbors
-            neighbor_index = np.random.choice(
+            nbr_index = np.random.choice(
                 num_nodes, p=transition_probabilities[starting_index]
             )
 
             # Set current vertex (v = v_j)
-            starting_index = neighbor_index
+            starting_index = nbr_index
 
             # Add v into p_r
-            neighbor_node = node_map[neighbor_index]
-            path.append(neighbor_node)
+            nbr_node = node_map[nbr_index]
+            path.append(nbr_node)
 
             # Add p_r into P_v
             if index_map is not None:
-                if neighbor_node in index_map:
-                    index_map[neighbor_node].add(path_index)
+                if nbr_node in index_map:
+                    index_map[nbr_node].add(path_index)
                 else:
-                    index_map[neighbor_node] = {path_index}
+                    index_map[nbr_node] = {path_index}
 
         yield path
diff --git a/networkx/algorithms/sparsifiers.py b/networkx/algorithms/sparsifiers.py
index a94aee0d09d..5890a5b1e9a 100644
--- a/networkx/algorithms/sparsifiers.py
+++ b/networkx/algorithms/sparsifiers.py
@@ -136,11 +136,11 @@ def spanner(G, stretch, weight=None, seed=None):
                 # remove edges to centers with edge weight less than
                 # closest_center_weight
                 for neighbor in residual_graph.adj[v]:
-                    neighbor_cluster = clustering[neighbor]
-                    neighbor_weight = lightest_edge_weight[neighbor_cluster]
+                    nbr_cluster = clustering[neighbor]
+                    nbr_weight = lightest_edge_weight[nbr_cluster]
                     if (
-                        neighbor_cluster == closest_center
-                        or neighbor_weight < closest_center_weight
+                        nbr_cluster == closest_center
+                        or nbr_weight < closest_center_weight
                     ):
                         edges_to_remove.add((v, neighbor))
 
@@ -257,14 +257,14 @@ def _lightest_edge_dicts(residual_graph, clustering, node):
     lightest_edge_neighbor = {}
     lightest_edge_weight = {}
     for neighbor in residual_graph.adj[node]:
-        neighbor_center = clustering[neighbor]
+        nbr_center = clustering[neighbor]
         weight = residual_graph[node][neighbor]["weight"]
         if (
-            neighbor_center not in lightest_edge_weight
-            or weight < lightest_edge_weight[neighbor_center]
+            nbr_center not in lightest_edge_weight
+            or weight < lightest_edge_weight[nbr_center]
         ):
-            lightest_edge_neighbor[neighbor_center] = neighbor
-            lightest_edge_weight[neighbor_center] = weight
+            lightest_edge_neighbor[nbr_center] = neighbor
+            lightest_edge_weight[nbr_center] = weight
     return lightest_edge_neighbor, lightest_edge_weight
 
 
diff --git a/networkx/algorithms/summarization.py b/networkx/algorithms/summarization.py
index 26665e09b1a..236810f0d98 100644
--- a/networkx/algorithms/summarization.py
+++ b/networkx/algorithms/summarization.py
@@ -180,12 +180,12 @@ def dedensify(G, threshold, prefix=None, copy=True):
 
     auxiliary = {}
     for node in G:
-        high_degree_neighbors = frozenset(high_degree_nodes & set(G[node]))
-        if high_degree_neighbors:
-            if high_degree_neighbors in auxiliary:
-                auxiliary[high_degree_neighbors].add(node)
+        high_degree_nbrs = frozenset(high_degree_nodes & set(G[node]))
+        if high_degree_nbrs:
+            if high_degree_nbrs in auxiliary:
+                auxiliary[high_degree_nbrs].add(node)
             else:
-                auxiliary[high_degree_neighbors] = {node}
+                auxiliary[high_degree_nbrs] = {node}
 
     if copy:
         G = G.copy()
@@ -326,33 +326,33 @@ def _snap_eligible_group(G, groups, group_lookup, edge_types):
     -------
     tuple: group ID to split, and neighbor-groups participation_counts data structure
     """
-    neighbor_info = {node: {gid: Counter() for gid in groups} for node in group_lookup}
+    nbr_info = {node: {gid: Counter() for gid in groups} for node in group_lookup}
     for group_id in groups:
         current_group = groups[group_id]
 
-        # build neighbor_info for nodes in group
+        # build nbr_info for nodes in group
         for node in current_group:
-            neighbor_info[node] = {group_id: Counter() for group_id in groups}
+            nbr_info[node] = {group_id: Counter() for group_id in groups}
             edges = G.edges(node, keys=True) if G.is_multigraph() else G.edges(node)
             for edge in edges:
                 neighbor = edge[1]
                 edge_type = edge_types[edge]
                 neighbor_group_id = group_lookup[neighbor]
-                neighbor_info[node][neighbor_group_id][edge_type] += 1
+                nbr_info[node][neighbor_group_id][edge_type] += 1
 
         # check if group_id is eligible to be split
         group_size = len(current_group)
         for other_group_id in groups:
             edge_counts = Counter()
             for node in current_group:
-                edge_counts.update(neighbor_info[node][other_group_id].keys())
+                edge_counts.update(nbr_info[node][other_group_id].keys())
 
             if not all(count == group_size for count in edge_counts.values()):
-                # only the neighbor_info of the returned group_id is required for handling group splits
-                return group_id, neighbor_info
+                # only the nbr_info of the returned group_id is required for handling group splits
+                return group_id, nbr_info
 
-    # if no eligible groups, complete neighbor_info is calculated
-    return None, neighbor_info
+    # if no eligible groups, complete nbr_info is calculated
+    return None, nbr_info
 
 
 def _snap_split(groups, neighbor_info, group_lookup, group_id):
@@ -540,12 +540,12 @@ def snap_aggregation(
     for node, node_type in group_lookup.items():
         groups[node_type].add(node)
 
-    eligible_group_id, neighbor_info = _snap_eligible_group(
+    eligible_group_id, nbr_info = _snap_eligible_group(
         G, groups, group_lookup, edge_types
     )
     while eligible_group_id:
-        groups = _snap_split(groups, neighbor_info, group_lookup, eligible_group_id)
-        eligible_group_id, neighbor_info = _snap_eligible_group(
+        groups = _snap_split(groups, nbr_info, group_lookup, eligible_group_id)
+        eligible_group_id, nbr_info = _snap_eligible_group(
             G, groups, group_lookup, edge_types
         )
     return _snap_build_graph(
@@ -553,7 +553,7 @@ def snap_aggregation(
         groups,
         node_attributes,
         edge_attributes,
-        neighbor_info,
+        nbr_info,
         edge_types,
         prefix,
         supernode_attribute,
diff --git a/networkx/algorithms/tests/test_mis.py b/networkx/algorithms/tests/test_mis.py
index 379c5c07c7a..02be02d4c33 100644
--- a/networkx/algorithms/tests/test_mis.py
+++ b/networkx/algorithms/tests/test_mis.py
@@ -58,5 +58,5 @@ def test_random_graphs():
         G = nx.erdos_renyi_graph(i * 10 + 1, random.random())
         IS = nx.maximal_independent_set(G)
         assert G.subgraph(IS).number_of_edges() == 0
-        neighbors_of_MIS = set.union(*(set(G.neighbors(v)) for v in IS))
-        assert all(v in neighbors_of_MIS for v in set(G.nodes()).difference(IS))
+        nbrs_of_MIS = set.union(*(set(G.neighbors(v)) for v in IS))
+        assert all(v in nbrs_of_MIS for v in set(G.nodes()).difference(IS))
diff --git a/networkx/classes/graph.py b/networkx/classes/graph.py
index 5bbf079a47b..e149ab2eeb3 100644
--- a/networkx/classes/graph.py
+++ b/networkx/classes/graph.py
@@ -1547,8 +1547,8 @@ def clear_edges(self):
         >>> list(G.edges)
         []
         """
-        for neighbours_dict in self._adj.values():
-            neighbours_dict.clear()
+        for nbr_dict in self._adj.values():
+            nbr_dict.clear()
 
     def is_multigraph(self):
         """Returns True if graph is a multigraph, False otherwise."""
diff --git a/networkx/generators/duplication.py b/networkx/generators/duplication.py
index 6daa5a9c738..ef7f374bbda 100644
--- a/networkx/generators/duplication.py
+++ b/networkx/generators/duplication.py
@@ -76,10 +76,10 @@ def partial_duplication_graph(N, n, p, q, seed=None):
         G.add_node(new_node)
 
         # For each neighbor of u...
-        for neighbor_node in list(nx.all_neighbors(G, src_node)):
+        for nbr_node in list(nx.all_neighbors(G, src_node)):
             # Add the neighbor to v with probability p.
             if seed.random() < p:
-                G.add_edge(new_node, neighbor_node)
+                G.add_edge(new_node, nbr_node)
 
         # Join v and u with probability q.
         if seed.random() < q:
diff --git a/networkx/generators/line.py b/networkx/generators/line.py
index 731371d4d55..ccee9605584 100644
--- a/networkx/generators/line.py
+++ b/networkx/generators/line.py
@@ -355,12 +355,12 @@ def _odd_triangle(G, T):
         if e[0] not in G[e[1]]:
             raise nx.NetworkXError(f"Edge ({e[0]}, {e[1]}) not in graph")
 
-    T_neighbors = defaultdict(int)
+    T_nbrs = defaultdict(int)
     for t in T:
         for v in G[t]:
             if v not in T:
-                T_neighbors[v] += 1
-    return any(T_neighbors[v] in [1, 3] for v in T_neighbors)
+                T_nbrs[v] += 1
+    return any(T_nbrs[v] in [1, 3] for v in T_nbrs)
 
 
 def _find_partition(G, starting_cell):
diff --git a/networkx/generators/random_graphs.py b/networkx/generators/random_graphs.py
index 75487ef6a21..e08c4ce7d1f 100644
--- a/networkx/generators/random_graphs.py
+++ b/networkx/generators/random_graphs.py
@@ -911,16 +911,16 @@ def extended_barabasi_albert_graph(n, m, p, q, seed=None):
                 node = seed.choice(eligible_nodes)
 
                 # The available nodes do have a neighbor at least.
-                neighbor_nodes = list(G[node])
+                nbr_nodes = list(G[node])
 
                 # Choosing the other end that will get detached
-                src_node = seed.choice(neighbor_nodes)
+                src_node = seed.choice(nbr_nodes)
 
                 # Picking a target node that is not 'node' or
                 # neighbor with 'node', with preferential attachment
-                neighbor_nodes.append(node)
+                nbr_nodes.append(node)
                 dest_node = seed.choice(
-                    [nd for nd in attachment_preference if nd not in neighbor_nodes]
+                    [nd for nd in attachment_preference if nd not in nbr_nodes]
                 )
                 # Rewire
                 G.remove_edge(node, src_node)

From c0f5918a2e34679242f26c9c116fee3456e5974a Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Fri, 15 Dec 2023 23:12:53 +0400
Subject: [PATCH 007/129] DOC: add reference to
 fast_label_propagation_communities (#7167)

---
 doc/reference/algorithms/community.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/reference/algorithms/community.rst b/doc/reference/algorithms/community.rst
index 55f7ad61ab3..1d107099790 100644
--- a/doc/reference/algorithms/community.rst
+++ b/doc/reference/algorithms/community.rst
@@ -47,6 +47,7 @@ Label propagation
 
    asyn_lpa_communities
    label_propagation_communities
+   fast_label_propagation_communities
 
 Louvain Community Detection
 ---------------------------

From 6ad78426badf78347e59758d0ef324d51794d5e0 Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Sat, 16 Dec 2023 05:08:54 +0400
Subject: [PATCH 008/129] MAINT: use ruff format instead of black (#7160)

* use ruff format instead of black

* Rm pylint comment guards.

---------

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 .pre-commit-config.yaml                           |  9 +++------
 networkx/algorithms/assortativity/correlation.py  |  4 ++--
 networkx/algorithms/isomorphism/ismags.py         | 10 ++--------
 .../isomorphism/tests/test_vf2pp_helpers.py       | 15 +++++++++------
 networkx/algorithms/shortest_paths/generic.py     |  5 +++--
 networkx/algorithms/tests/test_bridges.py         |  2 +-
 networkx/utils/tests/test_misc.py                 |  3 ++-
 7 files changed, 22 insertions(+), 26 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index d27674aced6..719aedfbbb0 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,26 +2,23 @@
 # pre-commit install
 
 repos:
-  - repo: https://github.com/psf/black
-    rev: 23.9.1
-    hooks:
-      - id: black
   - repo: https://github.com/adamchainz/blacken-docs
     rev: 1.16.0
     hooks:
       - id: blacken-docs
   - repo: https://github.com/pre-commit/mirrors-prettier
-    rev: v3.0.3
+    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.0.291
+    rev: v0.1.8
     hooks:
       - id: ruff
         args:
           - --fix
+      - id: ruff-format
   - repo: local
     hooks:
       - id: generate_requirements.py
diff --git a/networkx/algorithms/assortativity/correlation.py b/networkx/algorithms/assortativity/correlation.py
index 35ea78d6d52..d517132ff21 100644
--- a/networkx/algorithms/assortativity/correlation.py
+++ b/networkx/algorithms/assortativity/correlation.py
@@ -94,7 +94,7 @@ def degree_assortativity_coefficient(G, x="out", y="in", weight=None, nodes=None
     else:
         degrees = {d for _, d in G.degree(nodes, weight=weight)}
 
-    mapping = {d: i for i, d, in enumerate(degrees)}
+    mapping = {d: i for i, d in enumerate(degrees)}
     M = degree_mixing_matrix(G, x=x, y=y, nodes=nodes, weight=weight, mapping=mapping)
 
     return _numeric_ac(M, mapping=mapping)
@@ -251,7 +251,7 @@ def numeric_assortativity_coefficient(G, attribute, nodes=None):
     if nodes is None:
         nodes = G.nodes
     vals = {G.nodes[n][attribute] for n in nodes}
-    mapping = {d: i for i, d, in enumerate(vals)}
+    mapping = {d: i for i, d in enumerate(vals)}
     M = attribute_mixing_matrix(G, attribute, nodes, mapping)
     return _numeric_ac(M, mapping)
 
diff --git a/networkx/algorithms/isomorphism/ismags.py b/networkx/algorithms/isomorphism/ismags.py
index 1fe920adfbb..24819faf95c 100644
--- a/networkx/algorithms/isomorphism/ismags.py
+++ b/networkx/algorithms/isomorphism/ismags.py
@@ -882,10 +882,7 @@ def _map_nodes(self, sgn, candidates, constraints, mapping=None, to_be_mapped=No
 
             # The next node is the one that is unmapped and has fewest
             # candidates
-            # Pylint disables because it's a one-shot function.
-            next_sgn = min(
-                left_to_map, key=lambda n: min(new_candidates[n], key=len)
-            )  # pylint: disable=cell-var-from-loop
+            next_sgn = min(left_to_map, key=lambda n: min(new_candidates[n], key=len))
             yield from self._map_nodes(
                 next_sgn,
                 new_candidates,
@@ -909,10 +906,7 @@ def _largest_common_subgraph(self, candidates, constraints, to_be_mapped=None):
         # "part of" the subgraph in to_be_mapped, and we make it a little
         # smaller every iteration.
 
-        # pylint disable because it's guarded against by default value
-        current_size = len(
-            next(iter(to_be_mapped), [])
-        )  # pylint: disable=stop-iteration-return
+        current_size = len(next(iter(to_be_mapped), []))
 
         found_iso = False
         if current_size <= len(self.graph):
diff --git a/networkx/algorithms/isomorphism/tests/test_vf2pp_helpers.py b/networkx/algorithms/isomorphism/tests/test_vf2pp_helpers.py
index 1a46c38f501..0e29b1be617 100644
--- a/networkx/algorithms/isomorphism/tests/test_vf2pp_helpers.py
+++ b/networkx/algorithms/isomorphism/tests/test_vf2pp_helpers.py
@@ -57,8 +57,9 @@ def test_single_node(self):
             dict(zip(G2, it.cycle(labels_many))),
             "label",
         )
-        l1, l2 = nx.get_node_attributes(G1, "label"), nx.get_node_attributes(
-            G2, "label"
+        l1, l2 = (
+            nx.get_node_attributes(G1, "label"),
+            nx.get_node_attributes(G2, "label"),
         )
 
         gparams = _GraphParameters(
@@ -118,8 +119,9 @@ def test_matching_order(self):
             dict(zip(G2, it.cycle(labels))),
             "label",
         )
-        l1, l2 = nx.get_node_attributes(G1, "label"), nx.get_node_attributes(
-            G2, "label"
+        l1, l2 = (
+            nx.get_node_attributes(G1, "label"),
+            nx.get_node_attributes(G2, "label"),
         )
         gparams = _GraphParameters(
             G1,
@@ -155,8 +157,9 @@ def test_matching_order_all_branches(self):
         G2.nodes[4]["label"] = "red"
         G2.nodes[5]["label"] = "blue"
 
-        l1, l2 = nx.get_node_attributes(G1, "label"), nx.get_node_attributes(
-            G2, "label"
+        l1, l2 = (
+            nx.get_node_attributes(G1, "label"),
+            nx.get_node_attributes(G2, "label"),
         )
         gparams = _GraphParameters(
             G1,
diff --git a/networkx/algorithms/shortest_paths/generic.py b/networkx/algorithms/shortest_paths/generic.py
index 0d1bb5795f9..2d3f75c04e5 100644
--- a/networkx/algorithms/shortest_paths/generic.py
+++ b/networkx/algorithms/shortest_paths/generic.py
@@ -647,8 +647,9 @@ def all_pairs_all_shortest_paths(G, weight=None, method="dijkstra"):
     single_source_all_shortest_paths
     """
     for n in G:
-        yield n, dict(
-            single_source_all_shortest_paths(G, n, weight=weight, method=method)
+        yield (
+            n,
+            dict(single_source_all_shortest_paths(G, n, weight=weight, method=method)),
         )
 
 
diff --git a/networkx/algorithms/tests/test_bridges.py b/networkx/algorithms/tests/test_bridges.py
index 9c3ceba607f..b47f5860083 100644
--- a/networkx/algorithms/tests/test_bridges.py
+++ b/networkx/algorithms/tests/test_bridges.py
@@ -127,7 +127,7 @@ def test_no_weight(self):
         inf = float("inf")
         expected = {(3, 4, inf), (4, 3, inf)}
         assert next(nx.local_bridges(self.BB)) in expected
-        expected = {(u, v, 3) for u, v, in self.square.edges}
+        expected = {(u, v, 3) for u, v in self.square.edges}
         assert set(nx.local_bridges(self.square)) == expected
         assert list(nx.local_bridges(self.tri)) == []
 
diff --git a/networkx/utils/tests/test_misc.py b/networkx/utils/tests/test_misc.py
index 18d2878f635..38e9a0e5aa3 100644
--- a/networkx/utils/tests/test_misc.py
+++ b/networkx/utils/tests/test_misc.py
@@ -247,7 +247,8 @@ def test_arbitrary_element(iterable_type, expected):
 
 
 @pytest.mark.parametrize(
-    "iterator", ((i for i in range(3)), iter([1, 2, 3]))  # generator
+    "iterator",
+    ((i for i in range(3)), iter([1, 2, 3])),  # generator
 )
 def test_arbitrary_element_raises(iterator):
     """Value error is raised when input is an iterator."""

From 75c0345d45477e3392288127da56365b04bf3512 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Sun, 17 Dec 2023 00:41:04 +0530
Subject: [PATCH 009/129] updated See also sec of argmap class (#7163)

* updated See also sec of argmap class

* Update decorators.py
---
 networkx/utils/decorators.py | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/networkx/utils/decorators.py b/networkx/utils/decorators.py
index cc15882da72..dfb39b40f34 100644
--- a/networkx/utils/decorators.py
+++ b/networkx/utils/decorators.py
@@ -686,10 +686,8 @@ class in broad terms to aid in understanding how to use it.
     not_implemented_for
     open_file
     nodes_or_number
-    random_state
     py_random_state
-    networkx.community.quality.require_partition
-    require_partition
+    networkx.algorithms.community.quality.require_partition
 
     """
 

From f34dda2c924924edb6a350c62420fb0187ab150f Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Sat, 16 Dec 2023 18:17:22 -0800
Subject: [PATCH 010/129] Modify GML test to fix invalid octal character
 warning. (#7159)

* Modify GML test to fix invalid octal character warning.

* Switch to unicode char.

* Rm extra unicode string indicators.
---
 networkx/readwrite/tests/test_gml.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/networkx/readwrite/tests/test_gml.py b/networkx/readwrite/tests/test_gml.py
index 869b21f6bb2..50eff5c3617 100644
--- a/networkx/readwrite/tests/test_gml.py
+++ b/networkx/readwrite/tests/test_gml.py
@@ -554,8 +554,8 @@ def assert_parse_error(gml):
             "directed 1 multigraph 1 ]"
         )
         assert_parse_error(
-            "graph [edge [ source u'u\4200' target u'u\4200' ] "
-            + "node [ id u'u\4200' label b ] ]"
+            "graph [edge [ source '\u4200' target '\u4200' ] "
+            + "node [ id '\u4200' label b ] ]"
         )
 
         def assert_generate_error(*args, **kwargs):

From 483ea9a4ebc51f813bf9c82dea294a35d7c53c10 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Mon, 18 Dec 2023 02:19:53 +0530
Subject: [PATCH 011/129] DOC : updated examples in mincost.py (#7169)

---
 networkx/algorithms/flow/mincost.py | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/networkx/algorithms/flow/mincost.py b/networkx/algorithms/flow/mincost.py
index cc8626c7c3c..7a6c3351190 100644
--- a/networkx/algorithms/flow/mincost.py
+++ b/networkx/algorithms/flow/mincost.py
@@ -182,6 +182,8 @@ def min_cost_flow(G, demand="demand", capacity="capacity", weight="weight"):
     >>> G.add_edge("b", "d", weight=1, capacity=9)
     >>> G.add_edge("c", "d", weight=2, capacity=5)
     >>> flowDict = nx.min_cost_flow(G)
+    >>> flowDict
+    {'a': {'b': 4, 'c': 1}, 'd': {}, 'b': {'d': 4}, 'c': {'d': 1}}
     """
     return nx.network_simplex(G, demand=demand, capacity=capacity, weight=weight)[1]
 
@@ -227,6 +229,21 @@ def cost_of_flow(G, flowDict, weight="weight"):
     cause problems). As a workaround you can use integer numbers by
     multiplying the relevant edge attributes by a convenient
     constant factor (eg 100).
+
+    Examples
+    --------
+    >>> G = nx.DiGraph()
+    >>> G.add_node("a", demand=-5)
+    >>> G.add_node("d", demand=5)
+    >>> G.add_edge("a", "b", weight=3, capacity=4)
+    >>> G.add_edge("a", "c", weight=6, capacity=10)
+    >>> G.add_edge("b", "d", weight=1, capacity=9)
+    >>> G.add_edge("c", "d", weight=2, capacity=5)
+    >>> flowDict = nx.min_cost_flow(G)
+    >>> flowDict
+    {'a': {'b': 4, 'c': 1}, 'd': {}, 'b': {'d': 4}, 'c': {'d': 1}}
+    >>> nx.cost_of_flow(G, flowDict)
+    24
     """
     return sum((flowDict[u][v] * d.get(weight, 0) for u, v, d in G.edges(data=True)))
 

From d68caf64b057f3c5f0adf4f09ce3843e4f2395c4 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Sun, 17 Dec 2023 13:20:14 -0800
Subject: [PATCH 012/129] Ensure warnings related to changes in shortest_path
 returns are visible to users (#7161)

* Update shortest_path warning.

* Update single_target_shortest_path_length futurewarning.

* Update warnings filters in conftest.

* Update developer docs.
---
 doc/developer/deprecations.rst                   |  8 ++++----
 networkx/algorithms/shortest_paths/generic.py    | 13 +++++++++++--
 networkx/algorithms/shortest_paths/unweighted.py | 10 ++++++++--
 networkx/conftest.py                             |  8 ++++----
 4 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/doc/developer/deprecations.rst b/doc/developer/deprecations.rst
index a2c6700cec0..3b8ce95c573 100644
--- a/doc/developer/deprecations.rst
+++ b/doc/developer/deprecations.rst
@@ -46,10 +46,6 @@ Version 3.3
 * Remove pydot functionality ``drawing/nx_pydot.py``, if pydot is still not being maintained. See #5723
 * Remove the ``forest_str`` function from ``readwrite/text.py``. Replace
   existing usages with ``write_network_text``.
-* Change ``single_target_shortest_path_length`` in ``algorithms/shortest_path/unweighted.py``
-  to return a dict. See #6527
-* Change ``shortest_path`` in ``algorithms/shortest_path/generic.py``
-  to return a iterator. See #6527
 
 Version 3.4
 ~~~~~~~~~~~
@@ -69,3 +65,7 @@ Version 3.5
 * Remove ``all_triplets`` from ``algorithms/triads.py``
 * Remove ``random_triad`` from ``algorithms/triad.py``.
 * Add `not_implemented_for("multigraph”)` decorator to ``k_core``, ``k_shell``, ``k_crust`` and ``k_corona`` functions.
+* Change ``single_target_shortest_path_length`` in ``algorithms/shortest_path/unweighted.py``
+  to return a dict. See #6527
+* Change ``shortest_path`` in ``algorithms/shortest_path/generic.py``
+  to return a iterator. See #6527
diff --git a/networkx/algorithms/shortest_paths/generic.py b/networkx/algorithms/shortest_paths/generic.py
index 2d3f75c04e5..1ed47aa7144 100644
--- a/networkx/algorithms/shortest_paths/generic.py
+++ b/networkx/algorithms/shortest_paths/generic.py
@@ -135,8 +135,17 @@ def shortest_path(G, source=None, target=None, weight=None, method="dijkstra"):
     method = "unweighted" if weight is None else method
     if source is None:
         if target is None:
-            msg = "shortest_path for all_pairs will return an iterator in v3.3"
-            warnings.warn(msg, DeprecationWarning)
+            warnings.warn(
+                (
+                    "\n\nshortest_path will return an iterator that yields\n"
+                    "(node, path) pairs instead of a dictionary when source\n"
+                    "and target are unspecified beginning in version 3.5\n\n"
+                    "To keep the current behavior, use:\n\n"
+                    "\tdict(nx.shortest_path(G))"
+                ),
+                FutureWarning,
+                stacklevel=3,
+            )
 
             # Find paths between all pairs.
             if method == "unweighted":
diff --git a/networkx/algorithms/shortest_paths/unweighted.py b/networkx/algorithms/shortest_paths/unweighted.py
index 78df41bc389..bc329c55263 100644
--- a/networkx/algorithms/shortest_paths/unweighted.py
+++ b/networkx/algorithms/shortest_paths/unweighted.py
@@ -135,8 +135,14 @@ def single_target_shortest_path_length(G, target, cutoff=None):
     if target not in G:
         raise nx.NodeNotFound(f"Target {target} is not in G")
 
-    msg = "single_target_shortest_path_length will return a dict starting in v3.3"
-    warnings.warn(msg, DeprecationWarning)
+    warnings.warn(
+        (
+            "\n\nsingle_target_shortest_path_length will return a dict instead of"
+            "\nan iterator in version 3.5"
+        ),
+        FutureWarning,
+        stacklevel=3,
+    )
 
     if cutoff is None:
         cutoff = float("inf")
diff --git a/networkx/conftest.py b/networkx/conftest.py
index ef3551f4156..41f4789c330 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -94,13 +94,13 @@ def set_warnings():
     )
     warnings.filterwarnings(
         "ignore",
-        category=DeprecationWarning,
-        message="single_target_shortest_path_length will",
+        category=FutureWarning,
+        message="\n\nsingle_target_shortest_path_length",
     )
     warnings.filterwarnings(
         "ignore",
-        category=DeprecationWarning,
-        message="shortest_path for all_pairs",
+        category=FutureWarning,
+        message="\n\nshortest_path",
     )
     warnings.filterwarnings(
         "ignore", category=DeprecationWarning, message="\nforest_str is deprecated"

From 92afda97fcd05abae7c3b6efa3e880943cf3ee39 Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Mon, 18 Dec 2023 08:52:09 +0400
Subject: [PATCH 013/129] Sync up behavior of is_{type} for empty graphs
 (#5849)

Improve consistency of property-checking functions (i.e. is_something)
for empty graph inputs.

Tend towards NetworkXPointlessConcept exceptions for consistency.

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 networkx/algorithms/chordal.py                       |  2 ++
 .../components/tests/test_strongly_connected.py      |  3 ---
 .../components/tests/test_weakly_connected.py        |  6 ++++++
 networkx/algorithms/dag.py                           |  3 ++-
 networkx/algorithms/distance_regular.py              |  2 ++
 networkx/algorithms/regular.py                       |  2 ++
 networkx/algorithms/tests/test_dag.py                |  8 +++++++-
 networkx/algorithms/tests/test_distance_regular.py   |  9 +++++++++
 networkx/algorithms/tests/test_euler.py              |  7 +++++++
 networkx/algorithms/tests/test_regular.py            |  6 ++++++
 networkx/algorithms/tree/tests/test_recognition.py   | 12 ++++++++++++
 11 files changed, 55 insertions(+), 5 deletions(-)

diff --git a/networkx/algorithms/chordal.py b/networkx/algorithms/chordal.py
index 2aa56798317..0793761027a 100644
--- a/networkx/algorithms/chordal.py
+++ b/networkx/algorithms/chordal.py
@@ -339,6 +339,8 @@ def _find_chordality_breaker(G, s=None, treewidth_bound=sys.maxsize):
 
     It ignores any self loops.
     """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept("Graph has no nodes.")
     unnumbered = set(G)
     if s is None:
         s = arbitrary_element(G)
diff --git a/networkx/algorithms/components/tests/test_strongly_connected.py b/networkx/algorithms/components/tests/test_strongly_connected.py
index f1c773026a6..6d4ea855229 100644
--- a/networkx/algorithms/components/tests/test_strongly_connected.py
+++ b/networkx/algorithms/components/tests/test_strongly_connected.py
@@ -186,9 +186,6 @@ def test_connected_raise(self):
             with pytest.deprecated_call():
                 next(nx.strongly_connected_components_recursive(G))
         pytest.raises(NetworkXNotImplemented, nx.is_strongly_connected, G)
-        pytest.raises(
-            nx.NetworkXPointlessConcept, nx.is_strongly_connected, nx.DiGraph()
-        )
         pytest.raises(NetworkXNotImplemented, nx.condensation, G)
 
     strong_cc_methods = (
diff --git a/networkx/algorithms/components/tests/test_weakly_connected.py b/networkx/algorithms/components/tests/test_weakly_connected.py
index e313263668c..f014478930f 100644
--- a/networkx/algorithms/components/tests/test_weakly_connected.py
+++ b/networkx/algorithms/components/tests/test_weakly_connected.py
@@ -88,3 +88,9 @@ def test_connected_mutability(self):
             assert len(seen & component) == 0
             seen.update(component)
             component.clear()
+
+
+def test_is_weakly_connected_empty_graph_raises():
+    G = nx.DiGraph()
+    with pytest.raises(nx.NetworkXPointlessConcept, match="Connectivity is undefined"):
+        nx.is_weakly_connected(G)
diff --git a/networkx/algorithms/dag.py b/networkx/algorithms/dag.py
index 58138c340c4..eb3a064e4b2 100644
--- a/networkx/algorithms/dag.py
+++ b/networkx/algorithms/dag.py
@@ -641,7 +641,8 @@ def is_aperiodic(G):
     """
     if not G.is_directed():
         raise nx.NetworkXError("is_aperiodic not defined for undirected graphs")
-
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept("Graph has no nodes.")
     s = arbitrary_element(G)
     levels = {s: 0}
     this_level = [s]
diff --git a/networkx/algorithms/distance_regular.py b/networkx/algorithms/distance_regular.py
index 18c19ee00e0..da3754330d0 100644
--- a/networkx/algorithms/distance_regular.py
+++ b/networkx/algorithms/distance_regular.py
@@ -147,6 +147,8 @@ def intersection_array(G):
     global_parameters
     """
     # test for regular graph (all degrees must be equal)
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept("Graph has no nodes.")
     degree = iter(G.degree())
     (_, k) = next(degree)
     for _, knext in degree:
diff --git a/networkx/algorithms/regular.py b/networkx/algorithms/regular.py
index d3332342794..52b5ed6ee81 100644
--- a/networkx/algorithms/regular.py
+++ b/networkx/algorithms/regular.py
@@ -29,6 +29,8 @@ def is_regular(G):
     True
 
     """
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept("Graph has no nodes.")
     n1 = nx.utils.arbitrary_element(G)
     if not G.is_directed():
         d1 = G.degree(n1)
diff --git a/networkx/algorithms/tests/test_dag.py b/networkx/algorithms/tests/test_dag.py
index 540c0c55e4d..d26c9fd3b4d 100644
--- a/networkx/algorithms/tests/test_dag.py
+++ b/networkx/algorithms/tests/test_dag.py
@@ -618,11 +618,17 @@ def test_is_aperiodic_selfloop():
     assert nx.is_aperiodic(G)
 
 
-def test_is_aperiodic_raise():
+def test_is_aperiodic_undirected_raises():
     G = nx.Graph()
     pytest.raises(nx.NetworkXError, nx.is_aperiodic, G)
 
 
+def test_is_aperiodic_empty_graph():
+    G = nx.empty_graph(create_using=nx.DiGraph)
+    with pytest.raises(nx.NetworkXPointlessConcept, match="Graph has no nodes."):
+        nx.is_aperiodic(G)
+
+
 def test_is_aperiodic_bipartite():
     # Bipartite graph
     G = nx.DiGraph(nx.davis_southern_women_graph())
diff --git a/networkx/algorithms/tests/test_distance_regular.py b/networkx/algorithms/tests/test_distance_regular.py
index d336b188214..6cbeb2a6d73 100644
--- a/networkx/algorithms/tests/test_distance_regular.py
+++ b/networkx/algorithms/tests/test_distance_regular.py
@@ -1,3 +1,5 @@
+import pytest
+
 import networkx as nx
 from networkx import is_strongly_regular
 
@@ -41,6 +43,13 @@ def test_intersection_array(self):
         assert c == [1, 2, 5]
 
 
+@pytest.mark.parametrize("f", (nx.is_distance_regular, nx.is_strongly_regular))
+def test_empty_graph_raises(f):
+    G = nx.Graph()
+    with pytest.raises(nx.NetworkXPointlessConcept, match="Graph has no nodes"):
+        f(G)
+
+
 class TestStronglyRegular:
     """Unit tests for the :func:`~networkx.is_strongly_regular`
     function.
diff --git a/networkx/algorithms/tests/test_euler.py b/networkx/algorithms/tests/test_euler.py
index 08eaf7fccc6..b5871f09b5a 100644
--- a/networkx/algorithms/tests/test_euler.py
+++ b/networkx/algorithms/tests/test_euler.py
@@ -5,6 +5,13 @@
 import networkx as nx
 
 
+@pytest.mark.parametrize("f", (nx.is_eulerian, nx.is_semieulerian))
+def test_empty_graph_raises(f):
+    G = nx.Graph()
+    with pytest.raises(nx.NetworkXPointlessConcept, match="Connectivity is undefined"):
+        f(G)
+
+
 class TestIsEulerian:
     def test_is_eulerian(self):
         assert nx.is_eulerian(nx.complete_graph(5))
diff --git a/networkx/algorithms/tests/test_regular.py b/networkx/algorithms/tests/test_regular.py
index 0c8e4e46582..a8b4c3a30de 100644
--- a/networkx/algorithms/tests/test_regular.py
+++ b/networkx/algorithms/tests/test_regular.py
@@ -68,6 +68,12 @@ def test_is_regular4(self):
         assert reg.is_regular(g)
 
 
+def test_is_regular_empty_graph_raises():
+    G = nx.Graph()
+    with pytest.raises(nx.NetworkXPointlessConcept, match="Graph has no nodes"):
+        nx.is_regular(G)
+
+
 class TestIsKRegular:
     def test_is_k_regular1(self):
         g = gen.cycle_graph(4)
diff --git a/networkx/algorithms/tree/tests/test_recognition.py b/networkx/algorithms/tree/tests/test_recognition.py
index a9c6c5aade9..105f5a89e9b 100644
--- a/networkx/algorithms/tree/tests/test_recognition.py
+++ b/networkx/algorithms/tree/tests/test_recognition.py
@@ -119,6 +119,12 @@ def test_emptybranch():
     assert not nx.is_arborescence(G)
 
 
+def test_is_branching_empty_graph_raises():
+    G = nx.DiGraph()
+    with pytest.raises(nx.NetworkXPointlessConcept, match="G has no nodes."):
+        nx.is_branching(G)
+
+
 def test_path():
     G = nx.DiGraph()
     nx.add_path(G, range(5))
@@ -160,3 +166,9 @@ def test_notarborescence2():
     G.add_edge(6, 4)
     assert not nx.is_branching(G)
     assert not nx.is_arborescence(G)
+
+
+def test_is_arborescense_empty_graph_raises():
+    G = nx.DiGraph()
+    with pytest.raises(nx.NetworkXPointlessConcept, match="G has no nodes."):
+        nx.is_arborescence(G)

From 59e6b7fb041d0f3b4b17b8474fa7d1580c4f0d99 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Mon, 18 Dec 2023 19:43:27 +0530
Subject: [PATCH 014/129] Added `NodeNotFound` exceptions to
 `_apply_prediction` and `simrank`, and ignored isolated nodes in
 `panther_similarity` (#7110)

* ignoring isolated nodes in panther_similarity

* added NodeNotFound in simrank_similarity

* added NodeNotFound in _apply_prediction

* bug fix

* added Raises sec to all funcs and updated error msg

* added Raises sec to simrank_similarity

* added tests to test_similarity.py and updated simrank_similarity docs

* updated link_prediction.py

* updated and added tests in test_link_prediction.py

* bug : updated NodeNotFound tests of simrank_similarity

* bug : updated test_simrank_target_not_found and style fixes

* added NetworkXUnfeasible to panther_similarity

* bug fix

* added NodeNotFound for panther_similarity

* style fix

* list() -> set()
---
 networkx/algorithms/link_prediction.py        |  91 ++++++++++-
 networkx/algorithms/similarity.py             |  49 +++++-
 .../algorithms/tests/test_link_prediction.py  | 153 +++++++++---------
 networkx/algorithms/tests/test_similarity.py  |  25 +++
 4 files changed, 233 insertions(+), 85 deletions(-)

diff --git a/networkx/algorithms/link_prediction.py b/networkx/algorithms/link_prediction.py
index 7335a77f5e0..21e89fbf160 100644
--- a/networkx/algorithms/link_prediction.py
+++ b/networkx/algorithms/link_prediction.py
@@ -37,6 +37,12 @@ def _apply_prediction(G, func, ebunch=None):
     """
     if ebunch is None:
         ebunch = nx.non_edges(G)
+    else:
+        for u, v in ebunch:
+            if u not in G:
+                raise nx.NodeNotFound(f"Node {u} not in G.")
+            if v not in G:
+                raise nx.NodeNotFound(f"Node {v} not in G.")
     return ((u, v, func(u, v)) for u, v in ebunch)
 
 
@@ -72,6 +78,14 @@ def resource_allocation_index(G, ebunch=None):
         An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
         pair of nodes and p is their resource allocation index.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.complete_graph(5)
@@ -127,6 +141,14 @@ def jaccard_coefficient(G, ebunch=None):
         An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
         pair of nodes and p is their Jaccard coefficient.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.complete_graph(5)
@@ -186,6 +208,14 @@ def adamic_adar_index(G, ebunch=None):
         An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
         pair of nodes and p is their Adamic-Adar index.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.complete_graph(5)
@@ -264,6 +294,17 @@ def common_neighbor_centrality(G, ebunch=None, alpha=0.8):
         pair of nodes and p is their Common Neighbor and Centrality based
         Parameterized Algorithm(CCPA) score.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NetworkXAlgorithmError
+        If self loops exsists in `ebunch` or in `G` (if `ebunch` is `None`).
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.complete_graph(5)
@@ -286,7 +327,7 @@ def common_neighbor_centrality(G, ebunch=None, alpha=0.8):
 
         def predict(u, v):
             if u == v:
-                raise nx.NetworkXAlgorithmError("Self links are not supported")
+                raise nx.NetworkXAlgorithmError("Self loops are not supported")
 
             return sum(1 for _ in nx.common_neighbors(G, u, v))
 
@@ -296,7 +337,7 @@ def predict(u, v):
 
         def predict(u, v):
             if u == v:
-                raise nx.NetworkXAlgorithmError("Self links are not supported")
+                raise nx.NetworkXAlgorithmError("Self loops are not supported")
             path_len = spl[u].get(v, inf)
 
             return alpha * sum(1 for _ in nx.common_neighbors(G, u, v)) + (
@@ -338,6 +379,14 @@ def preferential_attachment(G, ebunch=None):
         An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
         pair of nodes and p is their preferential attachment score.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.complete_graph(5)
@@ -402,6 +451,17 @@ def cn_soundarajan_hopcroft(G, ebunch=None, community="community"):
         An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
         pair of nodes and p is their score.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NetworkXAlgorithmError
+        If no community information is available for a node in `ebunch` or in `G` (if `ebunch` is `None`).
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.path_graph(3)
@@ -477,6 +537,17 @@ def ra_index_soundarajan_hopcroft(G, ebunch=None, community="community"):
         An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
         pair of nodes and p is their score.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NetworkXAlgorithmError
+        If no community information is available for a node in `ebunch` or in `G` (if `ebunch` is `None`).
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.Graph()
@@ -553,6 +624,18 @@ def within_inter_cluster(G, ebunch=None, delta=0.001, community="community"):
         An iterator of 3-tuples in the form (u, v, p) where (u, v) is a
         pair of nodes and p is their WIC measure.
 
+    Raises
+    ------
+    NetworkXNotImplemented
+        If `G` is a `DiGraph`, a `Multigraph` or a `MultiDiGraph`.
+
+    NetworkXAlgorithmError
+        - If `delta` is less than or equal to zero.
+        - If no community information is available for a node in `ebunch` or in `G` (if `ebunch` is `None`).
+
+    NodeNotFound
+        If `ebunch` has a node that is not in `G`.
+
     Examples
     --------
     >>> G = nx.Graph()
@@ -601,4 +684,6 @@ def _community(G, u, community):
     try:
         return node_u[community]
     except KeyError as err:
-        raise nx.NetworkXAlgorithmError("No community information") from err
+        raise nx.NetworkXAlgorithmError(
+            f"No community information available for Node {u}"
+        ) from err
diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index 92b0cf9a3e1..0ad6de6e6fe 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -1275,6 +1275,14 @@ def simrank(G, u, v):
         If neither ``source`` nor ``target`` is ``None``, this returns
         the similarity value for the given pair of nodes.
 
+    Raises
+    -------
+    ExceededMaxIterations
+        If the algorithm does not converge within ``max_iterations``.
+
+    NodeNotFound
+        If either ``source`` or ``target`` is not in `G`.
+
     Examples
     --------
     >>> G = nx.cycle_graph(2)
@@ -1311,8 +1319,21 @@ def simrank(G, u, v):
     import numpy as np
 
     nodelist = list(G)
-    s_indx = None if source is None else nodelist.index(source)
-    t_indx = None if target is None else nodelist.index(target)
+    if source is not None:
+        if source not in nodelist:
+            raise nx.NodeNotFound(f"Source node {source} not in G")
+        else:
+            s_indx = nodelist.index(source)
+    else:
+        s_indx = None
+
+    if target is not None:
+        if target not in nodelist:
+            raise nx.NodeNotFound(f"Target node {target} not in G")
+        else:
+            t_indx = nodelist.index(target)
+    else:
+        t_indx = None
 
     x = _simrank_similarity_numpy(
         G, s_indx, t_indx, importance_factor, max_iterations, tolerance
@@ -1535,6 +1556,18 @@ def panther_similarity(
         the self-similarity (i.e., ``v``) will not be included in
         the returned dictionary.
 
+    Raises
+    -------
+    NetworkXUnfeasible
+        If `source` is an isolated node.
+
+    NodeNotFound
+        If `source` is not in `G`.
+
+    Notes
+    -------
+        The isolated nodes in `G` are ignored.
+
     Examples
     --------
     >>> G = nx.star_graph(10)
@@ -1550,6 +1583,18 @@ def panther_similarity(
     """
     import numpy as np
 
+    if source not in G:
+        raise nx.NodeNotFound(f"Source node {source} not in G")
+
+    isolates = set(nx.isolates(G))
+
+    if source in isolates:
+        raise nx.NetworkXUnfeasible(
+            f"Panther similarity is not defined for the isolated source node {source}."
+        )
+
+    G = G.subgraph([node for node in G.nodes if node not in isolates]).copy()
+
     num_nodes = G.number_of_nodes()
     if num_nodes < k:
         warnings.warn(
diff --git a/networkx/algorithms/tests/test_link_prediction.py b/networkx/algorithms/tests/test_link_prediction.py
index 7fc04d20672..b4643b3420d 100644
--- a/networkx/algorithms/tests/test_link_prediction.py
+++ b/networkx/algorithms/tests/test_link_prediction.py
@@ -34,23 +34,17 @@ def test_S4(self):
         G = nx.star_graph(4)
         self.test(G, [(1, 2)], [(1, 2, 0.25)])
 
-    def test_notimplemented(self):
-        assert pytest.raises(
-            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
-        )
-        assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
-        )
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
         assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiDiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
+            nx.NetworkXNotImplemented, self.func, graph_type([(0, 1), (1, 2)]), [(0, 2)]
         )
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_no_common_neighbor(self):
         G = nx.Graph()
         G.add_nodes_from([0, 1])
@@ -80,23 +74,17 @@ def test_P4(self):
         G = nx.path_graph(4)
         self.test(G, [(0, 2)], [(0, 2, 0.5)])
 
-    def test_notimplemented(self):
-        assert pytest.raises(
-            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
-        )
-        assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
-        )
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
         assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiDiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
+            nx.NetworkXNotImplemented, self.func, graph_type([(0, 1), (1, 2)]), [(0, 2)]
         )
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_no_common_neighbor(self):
         G = nx.Graph()
         G.add_edges_from([(0, 1), (2, 3)])
@@ -131,23 +119,17 @@ def test_S4(self):
         G = nx.star_graph(4)
         self.test(G, [(1, 2)], [(1, 2, 1 / math.log(4))])
 
-    def test_notimplemented(self):
-        assert pytest.raises(
-            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
-        )
-        assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
-        )
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
         assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiDiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
+            nx.NetworkXNotImplemented, self.func, graph_type([(0, 1), (1, 2)]), [(0, 2)]
         )
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_no_common_neighbor(self):
         G = nx.Graph()
         G.add_nodes_from([0, 1])
@@ -190,6 +172,11 @@ def test_notimplemented(self, graph_type):
             nx.NetworkXNotImplemented, self.func, graph_type([(0, 1), (1, 2)]), [(0, 2)]
         )
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_no_common_neighbor(self):
         G = nx.Graph()
         G.add_nodes_from([0, 1])
@@ -223,23 +210,17 @@ def test_S4(self):
         G = nx.star_graph(4)
         self.test(G, [(0, 2)], [(0, 2, 4)])
 
-    def test_notimplemented(self):
-        assert pytest.raises(
-            nx.NetworkXNotImplemented, self.func, nx.DiGraph([(0, 1), (1, 2)]), [(0, 2)]
-        )
-        assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
-        )
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
         assert pytest.raises(
-            nx.NetworkXNotImplemented,
-            self.func,
-            nx.MultiDiGraph([(0, 1), (1, 2)]),
-            [(0, 2)],
+            nx.NetworkXNotImplemented, self.func, graph_type([(0, 1), (1, 2)]), [(0, 2)]
         )
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_zero_degrees(self):
         G = nx.Graph()
         G.add_nodes_from([0, 1])
@@ -282,17 +263,21 @@ def test_S4(self):
         G.nodes[4]["community"] = 0
         self.test(G, [(1, 2)], [(1, 2, 2)])
 
-    def test_notimplemented(self):
-        G = nx.DiGraph([(0, 1), (1, 2)])
-        G.add_nodes_from([0, 1, 2], community=0)
-        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
-        G = nx.MultiGraph([(0, 1), (1, 2)])
-        G.add_nodes_from([0, 1, 2], community=0)
-        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
-        G = nx.MultiDiGraph([(0, 1), (1, 2)])
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
+        G = graph_type([(0, 1), (1, 2)])
         G.add_nodes_from([0, 1, 2], community=0)
         assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_no_common_neighbor(self):
         G = nx.Graph()
         G.add_nodes_from([0, 1])
@@ -387,17 +372,21 @@ def test_S4(self):
         G.nodes[4]["community"] = 0
         self.test(G, [(1, 2)], [(1, 2, 0.25)])
 
-    def test_notimplemented(self):
-        G = nx.DiGraph([(0, 1), (1, 2)])
-        G.add_nodes_from([0, 1, 2], community=0)
-        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
-        G = nx.MultiGraph([(0, 1), (1, 2)])
-        G.add_nodes_from([0, 1, 2], community=0)
-        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
-        G = nx.MultiDiGraph([(0, 1), (1, 2)])
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
+        G = graph_type([(0, 1), (1, 2)])
         G.add_nodes_from([0, 1, 2], community=0)
         assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_no_common_neighbor(self):
         G = nx.Graph()
         G.add_nodes_from([0, 1])
@@ -495,17 +484,21 @@ def test_S4(self):
         G.nodes[4]["community"] = 0
         self.test(G, [(1, 2)], [(1, 2, 1 / self.delta)])
 
-    def test_notimplemented(self):
-        G = nx.DiGraph([(0, 1), (1, 2)])
-        G.add_nodes_from([0, 1, 2], community=0)
-        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
-        G = nx.MultiGraph([(0, 1), (1, 2)])
-        G.add_nodes_from([0, 1, 2], community=0)
-        assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
-        G = nx.MultiDiGraph([(0, 1), (1, 2)])
+    @pytest.mark.parametrize("graph_type", (nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph))
+    def test_notimplemented(self, graph_type):
+        G = graph_type([(0, 1), (1, 2)])
         G.add_nodes_from([0, 1, 2], community=0)
         assert pytest.raises(nx.NetworkXNotImplemented, self.func, G, [(0, 2)])
 
+    def test_node_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
+        G.nodes[0]["community"] = 0
+        G.nodes[1]["community"] = 1
+        G.nodes[2]["community"] = 0
+        G.nodes[3]["community"] = 0
+        assert pytest.raises(nx.NodeNotFound, self.func, G, [(0, 4)])
+
     def test_no_common_neighbor(self):
         G = nx.Graph()
         G.add_nodes_from([0, 1])
diff --git a/networkx/algorithms/tests/test_similarity.py b/networkx/algorithms/tests/test_similarity.py
index b7fcf90fa43..420c709c173 100644
--- a/networkx/algorithms/tests/test_similarity.py
+++ b/networkx/algorithms/tests/test_similarity.py
@@ -699,6 +699,16 @@ def test_simrank_max_iterations(self, alg):
         G = nx.cycle_graph(5)
         pytest.raises(nx.ExceededMaxIterations, alg, G, max_iterations=10)
 
+    def test_simrank_source_not_found(self):
+        G = nx.cycle_graph(5)
+        with pytest.raises(nx.NodeNotFound, match="Source node 10 not in G"):
+            nx.simrank_similarity(G, source=10)
+
+    def test_simrank_target_not_found(self):
+        G = nx.cycle_graph(5)
+        with pytest.raises(nx.NodeNotFound, match="Target node 10 not in G"):
+            nx.simrank_similarity(G, target=10)
+
     def test_simrank_between_versions(self):
         G = nx.cycle_graph(5)
         # _python tolerance 1e-4
@@ -819,6 +829,21 @@ def test_panther_similarity_weighted(self):
         sim = nx.panther_similarity(G, "v1", path_length=2, weight="w")
         assert sim == expected
 
+    def test_panther_similarity_source_not_found(self):
+        G = nx.Graph()
+        G.add_edges_from([(0, 1), (0, 2), (0, 3), (1, 2), (2, 4)])
+        with pytest.raises(nx.NodeNotFound, match="Source node 10 not in G"):
+            nx.panther_similarity(G, source=10)
+
+    def test_panther_similarity_isolated(self):
+        G = nx.Graph()
+        G.add_nodes_from(range(5))
+        with pytest.raises(
+            nx.NetworkXUnfeasible,
+            match="Panther similarity is not defined for the isolated source node 1.",
+        ):
+            nx.panther_similarity(G, source=1)
+
     def test_generate_random_paths_unweighted(self):
         np.random.seed(42)
 

From 267e33e99be42ed717a69817ddfbbd5c20238a2e Mon Sep 17 00:00:00 2001
From: Ayooluwa <43212808+Ay-slim@users.noreply.github.com>
Date: Mon, 18 Dec 2023 20:00:09 +0000
Subject: [PATCH 015/129] Document the walk_type argument default in
 directed_laplacian and similar functions. (#7171)

* Fixes networkx/networkx#7147

* Word documentation change properly based on PR review

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>

* Update walk_type documentation in laplacian_centrality function

* Update walk_type documentation in _transition_matrix and directed_combinatorial_laplacian matrix functions

---------

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 networkx/algorithms/centrality/laplacian.py |  7 +++++--
 networkx/linalg/laplacianmatrix.py          | 21 +++++++++++++++------
 2 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/networkx/algorithms/centrality/laplacian.py b/networkx/algorithms/centrality/laplacian.py
index e0a9a6d5172..d8a58e6b322 100644
--- a/networkx/algorithms/centrality/laplacian.py
+++ b/networkx/algorithms/centrality/laplacian.py
@@ -50,8 +50,11 @@ def laplacian_centrality(
     walk_type : string or None, optional (default=None)
         Optional parameter `walk_type` used when calling
         :func:`directed_laplacian_matrix <networkx.directed_laplacian_matrix>`.
-        If None, the transition matrix is selected depending on the properties
-        of the graph. Otherwise can be `random`, `lazy`, or `pagerank`.
+        One of ``"random"``, ``"lazy"``, or ``"pagerank"``. If ``walk_type=None``
+        (the default), then a value is selected according to the properties of `G`:
+        - ``walk_type="random"`` if `G` is strongly connected and aperiodic
+        - ``walk_type="lazy"`` if `G` is strongly connected but not aperiodic
+        - ``walk_type="pagerank"`` for all other cases.
 
     alpha : real (default = 0.95)
         Optional parameter `alpha` used when calling
diff --git a/networkx/linalg/laplacianmatrix.py b/networkx/linalg/laplacianmatrix.py
index 13763828131..17bfd6d362b 100644
--- a/networkx/linalg/laplacianmatrix.py
+++ b/networkx/linalg/laplacianmatrix.py
@@ -219,8 +219,11 @@ def directed_laplacian_matrix(
        If None, then each edge has weight 1.
 
     walk_type : string or None, optional (default=None)
-       If None, `P` is selected depending on the properties of the
-       graph. Otherwise is one of 'random', 'lazy', or 'pagerank'
+       One of ``"random"``, ``"lazy"``, or ``"pagerank"``. If ``walk_type=None``
+       (the default), then a value is selected according to the properties of `G`:
+       - ``walk_type="random"`` if `G` is strongly connected and aperiodic
+       - ``walk_type="lazy"`` if `G` is strongly connected but not aperiodic
+       - ``walk_type="pagerank"`` for all other cases.
 
     alpha : real
        (1 - alpha) is the teleportation probability used with pagerank
@@ -307,8 +310,11 @@ def directed_combinatorial_laplacian_matrix(
        If None, then each edge has weight 1.
 
     walk_type : string or None, optional (default=None)
-       If None, `P` is selected depending on the properties of the
-       graph. Otherwise is one of 'random', 'lazy', or 'pagerank'
+        One of ``"random"``, ``"lazy"``, or ``"pagerank"``. If ``walk_type=None``
+        (the default), then a value is selected according to the properties of `G`:
+        - ``walk_type="random"`` if `G` is strongly connected and aperiodic
+        - ``walk_type="lazy"`` if `G` is strongly connected but not aperiodic
+        - ``walk_type="pagerank"`` for all other cases.
 
     alpha : real
        (1 - alpha) is the teleportation probability used with pagerank
@@ -372,8 +378,11 @@ def _transition_matrix(G, nodelist=None, weight="weight", walk_type=None, alpha=
        If None, then each edge has weight 1.
 
     walk_type : string or None, optional (default=None)
-       If None, `P` is selected depending on the properties of the
-       graph. Otherwise is one of 'random', 'lazy', or 'pagerank'
+       One of ``"random"``, ``"lazy"``, or ``"pagerank"``. If ``walk_type=None``
+       (the default), then a value is selected according to the properties of `G`:
+        - ``walk_type="random"`` if `G` is strongly connected and aperiodic
+        - ``walk_type="lazy"`` if `G` is strongly connected but not aperiodic
+        - ``walk_type="pagerank"`` for all other cases.
 
     alpha : real
        (1 - alpha) is the teleportation probability used with pagerank

From d042db56312193f3f397877cffba00eb951dcd43 Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Thu, 21 Dec 2023 01:16:40 +0400
Subject: [PATCH 016/129] DOC: Add plots to classic graph generators docs
 (#7114)

* DOC: Add plots to classic graph generators docs

* Update conf.py

* make pre-commit happy
---
 doc/conf.py                    |  4 +-
 networkx/generators/classic.py | 76 +++++++++++++++++++++++++++++++++-
 2 files changed, 78 insertions(+), 2 deletions(-)

diff --git a/doc/conf.py b/doc/conf.py
index 1d8ea398768..f54a0228992 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -248,9 +248,11 @@
 
 plot_pre_code = """
 import networkx as nx
+import numpy as np
+np.random.seed(42)
 """
 
-plot_formats = [("png", 100), "pdf"]
+plot_formats = [("png", 100)]
 
 
 def setup(app):
diff --git a/networkx/generators/classic.py b/networkx/generators/classic.py
index 09d5d9938ed..4bb660b5a8a 100644
--- a/networkx/generators/classic.py
+++ b/networkx/generators/classic.py
@@ -75,6 +75,10 @@ def full_rary_tree(r, n, create_using=None):
     (if a leaf at the bottom level is missing, then so are all of the
     leaves to its right." [1]_
 
+    .. plot::
+
+        >>> nx.draw(nx.full_rary_tree(2, 10))
+
     Parameters
     ----------
     r : int
@@ -103,6 +107,10 @@ def full_rary_tree(r, n, create_using=None):
 def balanced_tree(r, h, create_using=None):
     """Returns the perfectly balanced `r`-ary tree of height `h`.
 
+    .. plot::
+
+        >>> nx.draw(nx.balanced_tree(2, 3))
+
     Parameters
     ----------
     r : int
@@ -149,6 +157,10 @@ def balanced_tree(r, h, create_using=None):
 def barbell_graph(m1, m2, create_using=None):
     """Returns the Barbell Graph: two complete graphs connected by a path.
 
+    .. plot::
+
+        >>> nx.draw(nx.barbell_graph(4, 2))
+
     Parameters
     ----------
     m1 : int
@@ -222,6 +234,10 @@ def binomial_tree(n, create_using=None):
     is defined recursively by linking two binomial trees of order k-1: the root of one is
     the leftmost child of the root of the other.
 
+    .. plot::
+
+        >>> nx.draw(nx.binomial_tree(3))
+
     Parameters
     ----------
     n : int
@@ -305,6 +321,10 @@ def circular_ladder_graph(n, create_using=None):
 
     Node labels are the integers 0 to n-1
 
+    .. plot::
+
+        >>> nx.draw(nx.circular_ladder_graph(5))
+
     """
     G = ladder_graph(n, create_using)
     G.add_edge(0, n - 1)
@@ -320,6 +340,10 @@ def circulant_graph(n, offsets, create_using=None):
     such that node $i$ is connected to nodes $(i + x) \mod n$ and $(i - x) \mod n$
     for all $x$ in $x_1, ..., x_m$. Thus $Ci_n(1)$ is a cycle graph.
 
+    .. plot::
+
+        >>> nx.draw(nx.circulant_graph(10, [1]))
+
     Parameters
     ----------
     n : integer
@@ -392,6 +416,10 @@ def cycle_graph(n, create_using=None):
 
     $C_n$ is a path with its two end-nodes connected.
 
+    .. plot::
+
+        >>> nx.draw(nx.cycle_graph(5))
+
     Parameters
     ----------
     n : int or iterable container of nodes
@@ -422,6 +450,10 @@ def dorogovtsev_goltsev_mendes_graph(n, create_using=None):
     - Total number of nodes = ``3 * (3**n + 1) / 2``
     - Total number of edges = ``3 ** (n + 1)``
 
+    .. plot::
+
+        >>> nx.draw(nx.dorogovtsev_goltsev_mendes_graph(3))
+
     Parameters
     ----------
     n : integer
@@ -476,6 +508,10 @@ def dorogovtsev_goltsev_mendes_graph(n, create_using=None):
 def empty_graph(n=0, create_using=None, default=Graph):
     """Returns the empty graph with n nodes and zero edges.
 
+    .. plot::
+
+        >>> nx.draw(nx.empty_graph(5))
+
     Parameters
     ----------
     n : int or iterable container of nodes (default = 0)
@@ -575,6 +611,10 @@ def ladder_graph(n, create_using=None):
 
     Node labels are the integers 0 to 2*n - 1.
 
+    .. plot::
+
+        >>> nx.draw(nx.ladder_graph(5))
+
     """
     G = empty_graph(2 * n, create_using)
     if G.is_directed():
@@ -592,6 +632,10 @@ def lollipop_graph(m, n, create_using=None):
 
     This is the Barbell Graph without the right barbell.
 
+    .. plot::
+
+        >>> nx.draw(nx.lollipop_graph(3, 4))
+
     Parameters
     ----------
     m, n : int or iterable container of nodes
@@ -664,6 +708,10 @@ def null_graph(create_using=None):
 def path_graph(n, create_using=None):
     """Returns the Path graph `P_n` of linearly connected nodes.
 
+    .. plot::
+
+        >>> nx.draw(nx.path_graph(5))
+
     Parameters
     ----------
     n : int or iterable
@@ -688,6 +736,10 @@ def star_graph(n, create_using=None):
 
     The star graph consists of one center node connected to n outer nodes.
 
+    .. plot::
+
+        >>> nx.draw(nx.star_graph(6))
+
     Parameters
     ----------
     n : int or iterable
@@ -724,6 +776,10 @@ def tadpole_graph(m, n, create_using=None):
     This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
     It looks like a tadpole. It is also called a kite graph or a dragon graph.
 
+    .. plot::
+
+        >>> nx.draw(nx.tadpole_graph(3, 5))
+
     Parameters
     ----------
     m, n : int or iterable container of nodes
@@ -776,7 +832,13 @@ def tadpole_graph(m, n, create_using=None):
 
 @nx._dispatch(graphs=None)
 def trivial_graph(create_using=None):
-    """Return the Trivial graph with one node (with label 0) and no edges."""
+    """Return the Trivial graph with one node (with label 0) and no edges.
+
+    .. plot::
+
+        >>> nx.draw(nx.trivial_graph(), with_labels=True)
+
+    """
     G = empty_graph(1, create_using)
     return G
 
@@ -793,6 +855,10 @@ def turan_graph(n, r):
     $r-(n \mod r)$ partitions of size $n/r$, rounded down, and
     $n \mod r$ partitions of size $n/r+1$, rounded down.
 
+    .. plot::
+
+        >>> nx.draw(nx.turan_graph(6, 2))
+
     Parameters
     ----------
     n : int
@@ -822,6 +888,10 @@ def wheel_graph(n, create_using=None):
 
     The wheel graph consists of a hub node connected to a cycle of (n-1) nodes.
 
+    .. plot::
+
+        >>> nx.draw(nx.wheel_graph(5))
+
     Parameters
     ----------
     n : int or iterable
@@ -851,6 +921,10 @@ def wheel_graph(n, create_using=None):
 def complete_multipartite_graph(*subset_sizes):
     """Returns the complete multipartite graph with the specified subset sizes.
 
+    .. plot::
+
+        >>> nx.draw(nx.complete_multipartite_graph(1, 2, 3))
+
     Parameters
     ----------
     subset_sizes : tuple of integers or tuple of node iterables

From b7d0b0cc8f7395dc9668d25379f3615752112c20 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Thu, 21 Dec 2023 02:01:10 -0800
Subject: [PATCH 017/129] Fix not_implemented_for decorator for is_regular and
 related functions (#7182)

* Add tests for NotImplementedError for is_regular.

* Fix NetworkXNotImplemented for is_regular and related fns.

* Handle similar instances in maxcut.

* Handle similar case for asyn_fluid.

* Handle similar case for tree_isomorphism.
---
 networkx/algorithms/approximation/maxcut.py          |  6 ++++--
 .../algorithms/approximation/tests/test_maxcut.py    | 12 ++++++++++++
 networkx/algorithms/community/asyn_fluid.py          |  3 ++-
 .../algorithms/community/tests/test_asyn_fluid.py    |  7 +++++++
 networkx/algorithms/distance_regular.py              |  6 ++++--
 .../isomorphism/tests/test_tree_isomorphism.py       | 10 ++++++++++
 networkx/algorithms/isomorphism/tree_isomorphism.py  |  3 ++-
 networkx/algorithms/tests/test_distance_regular.py   | 10 ++++++++++
 8 files changed, 51 insertions(+), 6 deletions(-)

diff --git a/networkx/algorithms/approximation/maxcut.py b/networkx/algorithms/approximation/maxcut.py
index ec62b346bb4..31ccdc9fde3 100644
--- a/networkx/algorithms/approximation/maxcut.py
+++ b/networkx/algorithms/approximation/maxcut.py
@@ -4,7 +4,8 @@
 __all__ = ["randomized_partitioning", "one_exchange"]
 
 
-@not_implemented_for("directed", "multigraph")
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
 @py_random_state(1)
 @nx._dispatch(edge_attrs="weight")
 def randomized_partitioning(G, seed=None, p=0.5, weight=None):
@@ -49,7 +50,8 @@ def _swap_node_partition(cut, node):
     return cut - {node} if node in cut else cut.union({node})
 
 
-@not_implemented_for("directed", "multigraph")
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
 @py_random_state(2)
 @nx._dispatch(edge_attrs="weight")
 def one_exchange(G, initial_cut=None, seed=None, weight=None):
diff --git a/networkx/algorithms/approximation/tests/test_maxcut.py b/networkx/algorithms/approximation/tests/test_maxcut.py
index 39291fbf14d..ef0424401e4 100644
--- a/networkx/algorithms/approximation/tests/test_maxcut.py
+++ b/networkx/algorithms/approximation/tests/test_maxcut.py
@@ -1,9 +1,21 @@
 import random
 
+import pytest
+
 import networkx as nx
 from networkx.algorithms.approximation import maxcut
 
 
+@pytest.mark.parametrize(
+    "f", (nx.approximation.randomized_partitioning, nx.approximation.one_exchange)
+)
+@pytest.mark.parametrize("graph_constructor", (nx.DiGraph, nx.MultiGraph))
+def test_raises_on_directed_and_multigraphs(f, graph_constructor):
+    G = graph_constructor([(0, 1), (1, 2)])
+    with pytest.raises(nx.NetworkXNotImplemented):
+        f(G)
+
+
 def _is_valid_cut(G, set1, set2):
     union = set1.union(set2)
     assert union == set(G.nodes)
diff --git a/networkx/algorithms/community/asyn_fluid.py b/networkx/algorithms/community/asyn_fluid.py
index 4c2223e6331..490bb046e7a 100644
--- a/networkx/algorithms/community/asyn_fluid.py
+++ b/networkx/algorithms/community/asyn_fluid.py
@@ -10,7 +10,8 @@
 __all__ = ["asyn_fluidc"]
 
 
-@not_implemented_for("directed", "multigraph")
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
 @py_random_state(3)
 @nx._dispatch
 def asyn_fluidc(G, k, max_iter=100, seed=None):
diff --git a/networkx/algorithms/community/tests/test_asyn_fluid.py b/networkx/algorithms/community/tests/test_asyn_fluid.py
index cd108dda369..6c023be773d 100644
--- a/networkx/algorithms/community/tests/test_asyn_fluid.py
+++ b/networkx/algorithms/community/tests/test_asyn_fluid.py
@@ -5,6 +5,13 @@
 from networkx.algorithms.community import asyn_fluidc
 
 
+@pytest.mark.parametrize("graph_constructor", (nx.DiGraph, nx.MultiGraph))
+def test_raises_on_directed_and_multigraphs(graph_constructor):
+    G = graph_constructor([(0, 1), (1, 2)])
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.community.asyn_fluidc(G, 1)
+
+
 def test_exceptions():
     test = Graph()
     test.add_node("a")
diff --git a/networkx/algorithms/distance_regular.py b/networkx/algorithms/distance_regular.py
index da3754330d0..936fd5a2216 100644
--- a/networkx/algorithms/distance_regular.py
+++ b/networkx/algorithms/distance_regular.py
@@ -109,7 +109,8 @@ def global_parameters(b, c):
     return ((y, b[0] - x - y, x) for x, y in zip(b + [0], [0] + c))
 
 
-@not_implemented_for("directed", "multigraph")
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
 @nx._dispatch
 def intersection_array(G):
     """Returns the intersection array of a distance-regular graph.
@@ -181,7 +182,8 @@ def intersection_array(G):
 
 
 # TODO There is a definition for directed strongly regular graphs.
-@not_implemented_for("directed", "multigraph")
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
 @nx._dispatch
 def is_strongly_regular(G):
     """Returns True if and only if the given graph is strongly
diff --git a/networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py b/networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py
index 95e5fec8728..fa1ab9bbaef 100644
--- a/networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py
+++ b/networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py
@@ -1,6 +1,8 @@
 import random
 import time
 
+import pytest
+
 import networkx as nx
 from networkx.algorithms.isomorphism.tree_isomorphism import (
     rooted_tree_isomorphism,
@@ -9,6 +11,14 @@
 from networkx.classes.function import is_directed
 
 
+@pytest.mark.parametrize("graph_constructor", (nx.DiGraph, nx.MultiGraph))
+def test_tree_isomorphism_raises_on_directed_and_multigraphs(graph_constructor):
+    t1 = graph_constructor([(0, 1)])
+    t2 = graph_constructor([(1, 2)])
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.isomorphism.tree_isomorphism(t1, t2)
+
+
 # have this work for graph
 # given two trees (either the directed or undirected)
 # transform t2 according to the isomorphism
diff --git a/networkx/algorithms/isomorphism/tree_isomorphism.py b/networkx/algorithms/isomorphism/tree_isomorphism.py
index 6e935063336..c0ef821c1e3 100644
--- a/networkx/algorithms/isomorphism/tree_isomorphism.py
+++ b/networkx/algorithms/isomorphism/tree_isomorphism.py
@@ -209,7 +209,8 @@ def rooted_tree_isomorphism(t1, root1, t2, root2):
     return isomorphism
 
 
-@not_implemented_for("directed", "multigraph")
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
 @nx._dispatch(graphs={"t1": 0, "t2": 1})
 def tree_isomorphism(t1, t2):
     """
diff --git a/networkx/algorithms/tests/test_distance_regular.py b/networkx/algorithms/tests/test_distance_regular.py
index 6cbeb2a6d73..545fb6dee6a 100644
--- a/networkx/algorithms/tests/test_distance_regular.py
+++ b/networkx/algorithms/tests/test_distance_regular.py
@@ -4,6 +4,16 @@
 from networkx import is_strongly_regular
 
 
+@pytest.mark.parametrize(
+    "f", (nx.is_distance_regular, nx.intersection_array, nx.is_strongly_regular)
+)
+@pytest.mark.parametrize("graph_constructor", (nx.DiGraph, nx.MultiGraph))
+def test_raises_on_directed_and_multigraphs(f, graph_constructor):
+    G = graph_constructor([(0, 1), (1, 2)])
+    with pytest.raises(nx.NetworkXNotImplemented):
+        f(G)
+
+
 class TestDistanceRegular:
     def test_is_distance_regular(self):
         assert nx.is_distance_regular(nx.icosahedral_graph())

From a97c162a9a4a055aeba705b958082fee2c4d8bca Mon Sep 17 00:00:00 2001
From: Dan Schult <dschult@colgate.edu>
Date: Fri, 22 Dec 2023 03:41:15 -0500
Subject: [PATCH 018/129] New PR for Fixes minimal d-separator function failing
 to handle cases where no d-separators exist (#7019)

* add check that minimal d-separating set is valid sepset

* make api change note

* add edge case where proposed sepset is not empty but does not separate

* fix typo in test

* improve efficiency of d_sep check

* finish fixing failing unit tests

* remove xml

* use existing ancestors function

* check non disjoint node sets raise error

* enforce disjoint node sets for d-separation

* add test for nondisjoint sets raising error

* fix test errors. allow `i` and `r` to be nodes instead of sets.

* add keyword-only indicators

* rename u -> x and v -> y; fix docs quotations

* rename i -> included and r -> restricted

* docstrings

* allow `included`, `restricted` to be nodes

* fix raise error for nondisjoint sets

* added nondisjoint test for `minimal_d_separated`

* added test of `included` and `restricted`

* add test of `included` and `restricted`; found bug

* rebase on main

* update func sigs according to dschult's suggestion

* updated docs with new func sig; ref new algorithm

* update `find_min...` to new alg; outline 2 helper funcs

* Designate 3.2 release

* implemented reachable; tests pass

* typo

* updated `find_minimal_d_separator` docs

* finish implement new alg for `is/find_min_d_sep..`

* reworking and adding to docs for d-separation

* remove release note

* cleanup extra files

* updated input checking and doc_strings

* deprecate d_separated and minimal_d_separator

* change stacklevel of deprecations

---------

Co-authored-by: Jaron Lee <jaron2005@gmail.com>
Co-authored-by: Alex Markham <alex.markham@causal.dev>
Co-authored-by: Alex Markham <markham@kth.se>
---
 doc/developer/deprecations.rst                |   2 +
 doc/reference/algorithms/d_separation.rst     |   4 +-
 networkx/algorithms/d_separation.py           | 797 ++++++++++++------
 .../algorithms/tests/test_d_separation.py     | 194 ++++-
 networkx/conftest.py                          |   6 +
 5 files changed, 698 insertions(+), 305 deletions(-)

diff --git a/doc/developer/deprecations.rst b/doc/developer/deprecations.rst
index 3b8ce95c573..8dfbccdc7ca 100644
--- a/doc/developer/deprecations.rst
+++ b/doc/developer/deprecations.rst
@@ -64,6 +64,8 @@ Version 3.5
 ~~~~~~~~~~~
 * Remove ``all_triplets`` from ``algorithms/triads.py``
 * Remove ``random_triad`` from ``algorithms/triad.py``.
+* Remove ``d_separated`` from ``algorithms/d_separation.py``.
+* Remove ``minimal_d_separator`` from ``algorithms/d_separation.py``.
 * Add `not_implemented_for("multigraph”)` decorator to ``k_core``, ``k_shell``, ``k_crust`` and ``k_corona`` functions.
 * Change ``single_target_shortest_path_length`` in ``algorithms/shortest_path/unweighted.py``
   to return a dict. See #6527
diff --git a/doc/reference/algorithms/d_separation.rst b/doc/reference/algorithms/d_separation.rst
index 053471b575b..09d34965e6a 100644
--- a/doc/reference/algorithms/d_separation.rst
+++ b/doc/reference/algorithms/d_separation.rst
@@ -6,6 +6,6 @@ D-Separation
 .. autosummary::
    :toctree: generated/
 
-   d_separated
+   is_d_separator
    is_minimal_d_separator
-   minimal_d_separator
+   find_minimal_d_separator
diff --git a/networkx/algorithms/d_separation.py b/networkx/algorithms/d_separation.py
index 4322b095822..dc1e105ee3a 100644
--- a/networkx/algorithms/d_separation.py
+++ b/networkx/algorithms/d_separation.py
@@ -11,88 +11,183 @@
 algorithm presented in [2]_.  Refer to [3]_, [4]_ for a couple of
 alternative algorithms.
 
-Here, we provide a brief overview of d-separation and related concepts that
-are relevant for understanding it:
-
-Blocking paths
---------------
+The functional interface in NetworkX consists of three functions:
 
-Before we overview, we introduce the following terminology to describe paths:
+- `find_minimal_d_separator` returns a minimal d-separator set ``z``.
+  That is, removing any node or nodes from it makes it no longer a d-separator.
+- `is_d_separator` checks if a given set is a d-separator.
+- `is_minimal_d_separator` checks if a given set is a minimal d-separator.
 
-- "open" path: A path between two nodes that can be traversed
-- "blocked" path: A path between two nodes that cannot be traversed
+D-separators
+------------
 
-A **collider** is a triplet of nodes along a path that is like the following:
-``... u -> c <- v ...``), where 'c' is a common successor of ``u`` and ``v``. A path
-through a collider is considered "blocked". When
-a node that is a collider, or a descendant of a collider is included in
-the d-separating set, then the path through that collider node is "open". If the
-path through the collider node is open, then we will call this node an open collider.
+Here, we provide a brief overview of d-separation and related concepts that
+are relevant for understanding it:
 
-The d-separation set blocks the paths between ``u`` and ``v``. If you include colliders,
-or their descendant nodes in the d-separation set, then those colliders will open up,
-enabling a path to be traversed if it is not blocked some other way.
+The ideas of d-separation and d-connection relate to paths being open or blocked.
+
+- A "path" is a sequence of nodes connected in order by edges. Unlike for most
+  graph theory analysis, the direction of the edges is ignored. Thus the path
+  can be thought of as a traditional path on the undirected version of the graph.
+- A "candidate d-separator" ``z`` is a set of nodes being considered as
+  possibly blocking all paths between two prescribed sets ``x`` and ``y`` of nodes.
+  We refer to each node in the candidate d-separator as "known".
+- A "collider" node on a path is a node that is a successor of its two neighbor
+  nodes on the path. That is, ``c`` is a collider if the edge directions
+  along the path look like ``... u -> c <- v ...``.
+- If a collider node or any of its descendants are "known", the collider
+  is called an "open collider". Otherwise it is a "blocking collider".
+- Any path can be "blocked" in two ways. If the path contains a "known" node
+  that is not a collider, the path is blocked. Also, if the path contains a
+  collider that is not a "known" node, the path is blocked.
+- A path is "open" if it is not blocked. That is, it is open if every node is
+  either an open collider or not a "known". Said another way, every
+  "known" in the path is a collider and every collider is open (has a
+  "known" as a inclusive descendant). The concept of "open path" is meant to
+  demonstrate a probabilistic conditional dependence between two nodes given
+  prescribed knowledge ("known" nodes).
+- Two sets ``x`` and ``y`` of nodes are "d-separated" by a set of nodes ``z``
+  if all paths between nodes in ``x`` and nodes in ``y`` are blocked. That is,
+  if there are no open paths from any node in ``x`` to any node in ``y``.
+  Such a set ``z`` is a "d-separator" of ``x`` and ``y``.
+- A "minimal d-separator" is a d-separator ``z`` for which no node or subset
+  of nodes can be removed with it still being a d-separator.
+
+The d-separator blocks some paths between ``x`` and ``y`` but opens others.
+Nodes in the d-separator block paths if the nodes are not colliders.
+But if a collider or its descendant nodes are in the d-separation set, the
+colliders are open, allowing a path through that collider.
 
 Illustration of D-separation with examples
 ------------------------------------------
 
-For a pair of two nodes, ``u`` and ``v``, all paths are considered open if
-there is a path between ``u`` and ``v`` that is not blocked. That means, there is an open
-path between ``u`` and ``v`` that does not encounter a collider, or a variable in the
-d-separating set.
+A pair of two nodes, ``u`` and ``v``, are d-connected if there is a path
+from ``u`` to ``v`` that is not blocked. That means, there is an open
+path from ``u`` to ``v``.
 
 For example, if the d-separating set is the empty set, then the following paths are
-unblocked between ``u`` and ``v``:
+open between ``u`` and ``v``:
 
-- u <- z -> v
-- u -> w -> ... -> z -> v
+- u <- n -> v
+- u -> w -> ... -> n -> v
 
-If for example, 'z' is in the d-separating set, then 'z' blocks those paths
-between ``u`` and ``v``.
+If  on the other hand, ``n`` is in the d-separating set, then ``n`` blocks
+those paths between ``u`` and ``v``.
 
-Colliders block a path by default if they and their descendants are not included
-in the d-separating set. An example of a path that is blocked when the d-separating
-set is empty is:
+Colliders block a path if they and their descendants are not included
+in the d-separating set. An example of a path that is blocked when the
+d-separating set is empty is:
 
-- u -> w -> ... -> z <- v
+- u -> w -> ... -> n <- v
 
-because 'z' is a collider in this path and 'z' is not in the d-separating set. However,
-if 'z' or a descendant of 'z' is included in the d-separating set, then the path through
-the collider at 'z' (... -> z <- ...) is now "open". 
+The node ``n`` is a collider in this path and is not in the d-separating set.
+So ``n`` blocks this path. However, if ``n`` or a descendant of ``n`` is
+included in the d-separating set, then the path through the collider
+at ``n`` (... -> n <- ...) is "open".
 
-D-separation is concerned with blocking all paths between u and v. Therefore, a
-d-separating set between ``u`` and ``v`` is one where all paths are blocked.
+D-separation is concerned with blocking all paths between nodes from ``x`` to ``y``.
+A d-separating set between ``x`` and ``y`` is one where all paths are blocked.
 
 D-separation and its applications in probability
 ------------------------------------------------
 
-D-separation is commonly used in probabilistic graphical models. D-separation
+D-separation is commonly used in probabilistic causal-graph models. D-separation
 connects the idea of probabilistic "dependence" with separation in a graph. If
-one assumes the causal Markov condition [5]_, then d-separation implies conditional
-independence in probability distributions.
+one assumes the causal Markov condition [5]_, (every node is conditionally
+independent of its non-descendants, given its parents) then d-separation implies
+conditional independence in probability distributions.
+Symmetrically, d-connection implies dependence.
+
+The intuition is as follows. The edges on a causal graph indicate which nodes
+influence the outcome of other nodes directly. An edge from u to v
+implies that the outcome of event ``u`` influences the probabilities for
+the outcome of event ``v``. Certainly knowing ``u`` changes predictions for ``v``.
+But also knowing ``v`` changes predictions for ``u``. The outcomes are dependent.
+Furthermore, an edge from ``v`` to ``w`` would mean that ``w`` and ``v`` are dependent
+and thus that ``u`` could indirectly influence ``w``.
+
+Without any knowledge about the system (candidate d-separating set is empty)
+a causal graph ``u -> v -> w`` allows all three nodes to be dependent. But
+if we know the outcome of ``v``, the conditional probabilities of outcomes for
+``u`` and ``w`` are independent of each other. That is, once we know the outcome
+for ```v`, the probabilities for ``w`` do not depend on the outcome for ``u``.
+This is the idea behind ``v`` blocking the path if it is "known" (in the candidate
+d-separating set).
+
+The same argument works whether the direction of the edges are both
+left-going and when both arrows head out from the middle. Having a "known"
+node on a path blocks the collider-free path because those relationships
+make the conditional probabilities independent.
+
+The direction of the causal edges does impact dependence precisely in the
+case of a collider e.g. ``u -> v <- w``. In that situation, both ``u`` and ``w``
+influence ``v```. But they do not directly influence each other. So without any
+knowledge of any outcomes, ``u`` and ``w`` are independent. That is the idea behind
+colliders blocking the path. But, if ``v`` is known, the conditional probabilities
+of ``u`` and ``w`` can be dependent. This is the heart of Berkson's Paradox [6]_.
+For example, suppose ``u`` and ``w`` are boolean events (they either happen or do not)
+and ``v`` represents the outcome "at least one of ``u`` and ``w`` occur". Then knowing
+``v`` is true makes the conditional probabilities of ``u`` and ``w`` dependent.
+Essentially, knowing that at least one of them is true raises the probability of
+each. But further knowledge that ``w`` is true (or false) change the conditional
+probability of ``u`` to either the original value or 1. So the conditional
+probability of ``u`` depends on the outcome of ``w`` even though there is no
+causal relationship between them. When a collider is known, dependence can
+occur across paths through that collider. This is the reason open colliders
+do not block paths.
+
+Furthermore, even if ``v`` is not "known", if one of its descendants is "known"
+we can use that information to know more about ``v`` which again makes
+``u`` and ``w`` potentially dependent. Suppose the chance of ``n`` occurring
+is much higher when ``v`` occurs ("at least one of ``u`` and ``w`` occur").
+Then if we know ``n`` occurred, it is more likely that ``v`` occurred and that
+makes the chance of ``u`` and ``w`` dependent. This is the idea behind why
+a collider does no block a path if any descendant of the collider is "known".
+
+When two sets of nodes ``x`` and ``y`` are d-separated by a set ``z``,
+it means that given the outcomes of the nodes in ``z``, the probabilities
+of outcomes of the nodes in ``x`` are independent of the outcomes of the
+nodes in ``y`` and vice versa.
 
 Examples
 --------
-
->>>
->>> # HMM graph with five states and observation nodes
-... g = nx.DiGraph()
->>> g.add_edges_from(
+A Hidden Markov Model with 5 observed states and 5 hidden states
+where the hidden states have causal relationships resulting in
+a path results in the following causal network. We check that
+early states along the path are separated from late state in
+the path by the d-separator of the middle hidden state.
+Thus if we condition on the middle hidden state, the early
+state probabilities are independent of the late state outcomes.
+
+>>> G = nx.DiGraph()
+>>> G.add_edges_from(
 ...     [
-...         ("S1", "S2"),
-...         ("S2", "S3"),
-...         ("S3", "S4"),
-...         ("S4", "S5"),
-...         ("S1", "O1"),
-...         ("S2", "O2"),
-...         ("S3", "O3"),
-...         ("S4", "O4"),
-...         ("S5", "O5"),
+...         ("H1", "H2"),
+...         ("H2", "H3"),
+...         ("H3", "H4"),
+...         ("H4", "H5"),
+...         ("H1", "O1"),
+...         ("H2", "O2"),
+...         ("H3", "O3"),
+...         ("H4", "O4"),
+...         ("H5", "O5"),
 ...     ]
 ... )
->>>
->>> # states/obs before 'S3' are d-separated from states/obs after 'S3'
-... nx.d_separated(g, {"S1", "S2", "O1", "O2"}, {"S4", "S5", "O4", "O5"}, {"S3"})
+>>> x, y, z = ({"H1", "O1"}, {"H5", "O5"}, {"H3"})
+>>> nx.is_d_separator(G, x, y, z)
+True
+>>> nx.is_minimal_d_separator(G, x, y, z)
+True
+>>> nx.is_minimal_d_separator(G, x, y, z | {"O3"})
+False
+>>> z = nx.find_minimal_d_separator(G, x | y, {"O2", "O3", "O4"})
+>>> z == {"H2", "H4"}
+True
+
+If no minimal_d_separator exists, `None` is returned
+
+>>> other_z = nx.find_minimal_d_separator(G, x | y, {"H2", "H3"})
+>>> other_z is None
 True
 
 
@@ -101,142 +196,192 @@
 
 .. [1] Pearl, J.  (2009).  Causality.  Cambridge: Cambridge University Press.
 
-.. [2] Darwiche, A.  (2009).  Modeling and reasoning with Bayesian networks. 
+.. [2] Darwiche, A.  (2009).  Modeling and reasoning with Bayesian networks.
    Cambridge: Cambridge University Press.
 
-.. [3] Shachter, R.  D.  (1998).
-   Bayes-ball: rational pastime (for determining irrelevance and requisite
-   information in belief networks and influence diagrams).
-   In , Proceedings of the Fourteenth Conference on Uncertainty in Artificial
-   Intelligence (pp.  480–487).
-   San Francisco, CA, USA: Morgan Kaufmann Publishers Inc.
+.. [3] Shachter, Ross D. "Bayes-ball: The rational pastime (for
+   determining irrelevance and requisite information in belief networks
+   and influence diagrams)." In Proceedings of the Fourteenth Conference
+   on Uncertainty in Artificial Intelligence (UAI), (pp. 480–487). 1998.
 
 .. [4] Koller, D., & Friedman, N. (2009).
    Probabilistic graphical models: principles and techniques. The MIT Press.
 
 .. [5] https://en.wikipedia.org/wiki/Causal_Markov_condition
 
+.. [6] https://en.wikipedia.org/wiki/Berkson%27s_paradox
+
 """
 
 from collections import deque
+from itertools import chain
 
 import networkx as nx
 from networkx.utils import UnionFind, not_implemented_for
 
-__all__ = ["d_separated", "minimal_d_separator", "is_minimal_d_separator"]
+__all__ = [
+    "is_d_separator",
+    "is_minimal_d_separator",
+    "find_minimal_d_separator",
+    "d_separated",
+    "minimal_d_separator",
+]
 
 
 @not_implemented_for("undirected")
 @nx._dispatch
-def d_separated(G, x, y, z):
-    """
-    Return whether node sets ``x`` and ``y`` are d-separated by ``z``.
+def is_d_separator(G, x, y, z):
+    """Return whether node sets `x` and `y` are d-separated by `z`.
 
     Parameters
     ----------
-    G : graph
+    G : nx.DiGraph
         A NetworkX DAG.
 
-    x : set
-        First set of nodes in ``G``.
+    x : node or set of nodes
+        First node or set of nodes in `G`.
 
-    y : set
-        Second set of nodes in ``G``.
+    y : node or set of nodes
+        Second node or set of nodes in `G`.
 
-    z : set
-        Set of conditioning nodes in ``G``. Can be empty set.
+    z : node or set of nodes
+        Potential separator (set of conditioning nodes in `G`). Can be empty set.
 
     Returns
     -------
     b : bool
-        A boolean that is true if ``x`` is d-separated from ``y`` given ``z`` in ``G``.
+        A boolean that is true if `x` is d-separated from `y` given `z` in `G`.
 
     Raises
     ------
     NetworkXError
-        The *d-separation* test is commonly used with directed
-        graphical models which are acyclic.  Accordingly, the algorithm
-        raises a :exc:`NetworkXError` if the input graph is not a DAG.
+        The *d-separation* test is commonly used on disjoint sets of
+        nodes in acyclic directed graphs.  Accordingly, the algorithm
+        raises a :exc:`NetworkXError` if the node sets are not
+        disjoint or if the input graph is not a DAG.
 
     NodeNotFound
         If any of the input nodes are not found in the graph,
-        a :exc:`NodeNotFound` exception is raised.
+        a :exc:`NodeNotFound` exception is raised
 
     Notes
     -----
     A d-separating set in a DAG is a set of nodes that
     blocks all paths between the two sets. Nodes in `z`
     block a path if they are part of the path and are not a collider,
-    or a descendant of a collider. A collider structure along a path
+    or a descendant of a collider. Also colliders that are not in `z`
+    block a path. A collider structure along a path
     is ``... -> c <- ...`` where ``c`` is the collider node.
 
     https://en.wikipedia.org/wiki/Bayesian_network#d-separation
     """
+    try:
+        x = {x} if x in G else x
+        y = {y} if y in G else y
+        z = {z} if z in G else z
+
+        intersection = x & y or x & z or y & z
+        if intersection:
+            raise nx.NetworkXError(
+                f"The sets are not disjoint, with intersection {intersection}"
+            )
+
+        set_v = x | y | z
+        if set_v - G.nodes:
+            raise nx.NodeNotFound(f"The node(s) {set_v - G.nodes} are not found in G")
+    except TypeError:
+        raise nx.NodeNotFound("One of x, y, or z is not a node or a set of nodes in G")
 
     if not nx.is_directed_acyclic_graph(G):
         raise nx.NetworkXError("graph should be directed acyclic")
 
-    union_xyz = x.union(y).union(z)
-
-    if any(n not in G.nodes for n in union_xyz):
-        raise nx.NodeNotFound("one or more specified nodes not found in the graph")
-
-    G_copy = G.copy()
-
-    # transform the graph by removing leaves that are not in x | y | z
-    # until no more leaves can be removed.
-    leaves = deque([n for n in G_copy.nodes if G_copy.out_degree[n] == 0])
-    while len(leaves) > 0:
-        leaf = leaves.popleft()
-        if leaf not in union_xyz:
-            for p in G_copy.predecessors(leaf):
-                if G_copy.out_degree[p] == 1:
-                    leaves.append(p)
-            G_copy.remove_node(leaf)
-
-    # transform the graph by removing outgoing edges from the
-    # conditioning set.
-    edges_to_remove = list(G_copy.out_edges(z))
-    G_copy.remove_edges_from(edges_to_remove)
-
-    # use disjoint-set data structure to check if any node in `x`
-    # occurs in the same weakly connected component as a node in `y`.
-    disjoint_set = UnionFind(G_copy.nodes())
-    for component in nx.weakly_connected_components(G_copy):
-        disjoint_set.union(*component)
-    disjoint_set.union(*x)
-    disjoint_set.union(*y)
-
-    if x and y and disjoint_set[next(iter(x))] == disjoint_set[next(iter(y))]:
-        return False
-    else:
-        return True
+    # contains -> and <-> edges from starting node T
+    forward_deque = deque([])
+    forward_visited = set()
+
+    # contains <- and - edges from starting node T
+    backward_deque = deque(x)
+    backward_visited = set()
+
+    ancestors_or_z = set().union(*[nx.ancestors(G, node) for node in x]) | z | x
+
+    while forward_deque or backward_deque:
+        if backward_deque:
+            node = backward_deque.popleft()
+            backward_visited.add(node)
+            if node in y:
+                return False
+            if node in z:
+                continue
+
+            # add <- edges to backward deque
+            backward_deque.extend(G.pred[node].keys() - backward_visited)
+            # add -> edges to forward deque
+            forward_deque.extend(G.succ[node].keys() - forward_visited)
+
+        if forward_deque:
+            node = forward_deque.popleft()
+            forward_visited.add(node)
+            if node in y:
+                return False
+
+            # Consider if -> node <- is opened due to ancestor of node in z
+            if node in ancestors_or_z:
+                # add <- edges to backward deque
+                backward_deque.extend(G.pred[node].keys() - backward_visited)
+            if node not in z:
+                # add -> edges to forward deque
+                forward_deque.extend(G.succ[node].keys() - forward_visited)
+
+    return True
 
 
 @not_implemented_for("undirected")
 @nx._dispatch
-def minimal_d_separator(G, u, v):
-    """Compute a minimal d-separating set between 'u' and 'v'.
+def find_minimal_d_separator(G, x, y, *, included=None, restricted=None):
+    """Returns a minimal d-separating set between `x` and `y` if possible
 
-    A d-separating set in a DAG is a set of nodes that blocks all paths
-    between the two nodes, 'u' and 'v'. This function
-    constructs a d-separating set that is "minimal", meaning it is the smallest
-    d-separating set for 'u' and 'v'. This is not necessarily
-    unique. For more details, see Notes.
+    A d-separating set in a DAG is a set of nodes that blocks all
+    paths between the two sets of nodes, `x` and `y`. This function
+    constructs a d-separating set that is "minimal", meaning no nodes can
+    be removed without it losing the d-separating property for `x` and `y`.
+    If no d-separating sets exist for `x` and `y`, this returns `None`.
+
+    In a DAG there may be more than one minimal d-separator between two
+    sets of nodes. Minimal d-separators are not always unique. This function
+    returns one minimal d-separator, or `None` if no d-separator exists.
+
+    Uses the algorithm presented in [1]_. The complexity of the algorithm
+    is :math:`O(m)`, where :math:`m` stands for the number of edges in
+    the subgraph of G consisting of only the ancestors of `x` and `y`.
+    For full details, see [1]_.
 
     Parameters
     ----------
     G : graph
         A networkx DAG.
-    u : node
-        A node in the graph, G.
-    v : node
-        A node in the graph, G.
+    x : set | node
+        A node or set of nodes in the graph.
+    y : set | node
+        A node or set of nodes in the graph.
+    included : set | node | None
+        A node or set of nodes which must be included in the found separating set,
+        default is None, which means the empty set.
+    restricted : set | node | None
+        Restricted node or set of nodes to consider. Only these nodes can be in
+        the found separating set, default is None meaning all nodes in ``G``.
+
+    Returns
+    -------
+    z : set | None
+        The minimal d-separating set, if at least one d-separating set exists,
+        otherwise None.
 
     Raises
     ------
     NetworkXError
-        Raises a :exc:`NetworkXError` if the input graph is not a DAG.
+        Raises a :exc:`NetworkXError` if the input graph is not a DAG
+        or if node sets `x`, `y`, and `included` are not disjoint.
 
     NodeNotFound
         If any of the input nodes are not found in the graph,
@@ -244,89 +389,98 @@ def minimal_d_separator(G, u, v):
 
     References
     ----------
-    .. [1] Tian, J., & Paz, A. (1998). Finding Minimal D-separators.
-
-    Notes
-    -----
-    This function only finds ``a`` minimal d-separator. It does not guarantee
-    uniqueness, since in a DAG there may be more than one minimal d-separator
-    between two nodes. Moreover, this only checks for minimal separators
-    between two nodes, not two sets. Finding minimal d-separators between
-    two sets of nodes is not supported.
-
-    Uses the algorithm presented in [1]_. The complexity of the algorithm
-    is :math:`O(|E_{An}^m|)`, where :math:`|E_{An}^m|` stands for the
-    number of edges in the moralized graph of the sub-graph consisting
-    of only the ancestors of 'u' and 'v'. For full details, see [1]_.
-
-    The algorithm works by constructing the moral graph consisting of just
-    the ancestors of `u` and `v`. Then it constructs a candidate for
-    a separating set  ``Z'`` from the predecessors of `u` and `v`.
-    Then BFS is run starting from `u` and marking nodes
-    found from ``Z'`` and calling those nodes ``Z''``.
-    Then BFS is run again starting from `v` and marking nodes if they are
-    present in ``Z''``. Those marked nodes are the returned minimal
-    d-separating set.
-
-    https://en.wikipedia.org/wiki/Bayesian_network#d-separation
+    .. [1] van der Zander, Benito, and Maciej Liśkiewicz. "Finding
+        minimal d-separators in linear time and applications." In
+        Uncertainty in Artificial Intelligence, pp. 637-647. PMLR, 2020.
     """
     if not nx.is_directed_acyclic_graph(G):
         raise nx.NetworkXError("graph should be directed acyclic")
 
-    union_uv = {u, v}
+    try:
+        x = {x} if x in G else x
+        y = {y} if y in G else y
 
-    if any(n not in G.nodes for n in union_uv):
-        raise nx.NodeNotFound("one or more specified nodes not found in the graph")
+        if included is None:
+            included = set()
+        elif included in G:
+            included = {included}
 
-    # first construct the set of ancestors of X and Y
-    x_anc = nx.ancestors(G, u)
-    y_anc = nx.ancestors(G, v)
-    D_anc_xy = x_anc.union(y_anc)
-    D_anc_xy.update((u, v))
+        if restricted is None:
+            restricted = set(G)
+        elif restricted in G:
+            restricted = {restricted}
 
-    # second, construct the moralization of the subgraph of Anc(X,Y)
-    moral_G = nx.moral_graph(G.subgraph(D_anc_xy))
+        set_y = x | y | included | restricted
+        if set_y - G.nodes:
+            raise nx.NodeNotFound(f"The node(s) {set_y - G.nodes} are not found in G")
+    except TypeError:
+        raise nx.NodeNotFound(
+            "One of x, y, included or restricted is not a node or set of nodes in G"
+        )
 
-    # find a separating set Z' in moral_G
-    Z_prime = set(G.predecessors(u)).union(set(G.predecessors(v)))
+    if not included <= restricted:
+        raise nx.NetworkXError(
+            f"Included nodes {included} must be in restricted nodes {restricted}"
+        )
 
-    # perform BFS on the graph from 'x' to mark
-    Z_dprime = _bfs_with_marks(moral_G, u, Z_prime)
-    Z = _bfs_with_marks(moral_G, v, Z_dprime)
-    return Z
+    intersection = x & y or x & included or y & included
+    if intersection:
+        raise nx.NetworkXError(
+            f"The sets x, y, included are not disjoint. Overlap: {intersection}"
+        )
+
+    nodeset = x | y | included
+    ancestors_x_y_included = nodeset.union(*[nx.ancestors(G, node) for node in nodeset])
+
+    z_init = restricted & (ancestors_x_y_included - (x | y))
+
+    x_closure = _reachable(G, x, ancestors_x_y_included, z_init)
+    if x_closure & y:
+        return None
+
+    z_updated = z_init & (x_closure | included)
+    y_closure = _reachable(G, y, ancestors_x_y_included, z_updated)
+    return z_updated & (y_closure | included)
 
 
 @not_implemented_for("undirected")
 @nx._dispatch
-def is_minimal_d_separator(G, u, v, z):
-    """Determine if a d-separating set is minimal.
+def is_minimal_d_separator(G, x, y, z, *, included=None, restricted=None):
+    """Determine if `z` is a minimal d-separator for `x` and `y`.
 
-    A d-separating set, `z`, in a DAG is a set of nodes that blocks
-    all paths between the two nodes, `u` and `v`. This function
-    verifies that a set is "minimal", meaning there is no smaller
-    d-separating set between the two nodes.
+    A d-separator, `z`, in a DAG is a set of nodes that blocks
+    all paths from nodes in set `x` to nodes in set `y`.
+    A minimal d-separator is a d-separator `z` such that removing
+    any subset of nodes makes it no longer a d-separator.
 
-    Note: This function checks whether `z` is a d-separator AND is minimal.
-    One can use the function `d_separated` to only check if `z` is a d-separator.
-    See examples below.
+    Note: This function checks whether `z` is a d-separator AND is
+    minimal. One can use the function `is_d_separator` to only check if
+    `z` is a d-separator. See examples below.
 
     Parameters
     ----------
     G : nx.DiGraph
-        The graph.
-    u : node
-        A node in the graph.
-    v : node
-        A node in the graph.
-    z : Set of nodes
-        The set of nodes to check if it is a minimal d-separating set.
-        The function :func:`d_separated` is called inside this function
+        A NetworkX DAG.
+    x : node | set
+        A node or set of nodes in the graph.
+    y : node | set
+        A node or set of nodes in the graph.
+    z : node | set
+        The node or set of nodes to check if it is a minimal d-separating set.
+        The function :func:`is_d_separator` is called inside this function
         to verify that `z` is in fact a d-separator.
+    included : set | node | None
+        A node or set of nodes which must be included in the found separating set,
+        default is ``None``, which means the empty set.
+    restricted : set | node | None
+        Restricted node or set of nodes to consider. Only these nodes can be in
+        the found separating set, default is ``None`` meaning all nodes in ``G``.
 
     Returns
     -------
     bool
-        Whether or not the set `z` is a d-separator and is also minimal.
+        Whether or not the set `z` is a minimal d-separator subject to
+        `restricted` nodes and `included` node constraints.
 
     Examples
     --------
@@ -338,7 +492,7 @@ def is_minimal_d_separator(G, u, v, z):
     >>> nx.is_minimal_d_separator(G, 0, 2, {1, 3, 4})
     False
     >>> # alternatively, if we only want to check that {1, 3, 4} is a d-separator
-    >>> nx.d_separated(G, {0}, {4}, {1, 3, 4})
+    >>> nx.is_d_separator(G, 0, 2, {1, 3, 4})
     True
 
     Raises
@@ -352,106 +506,217 @@ def is_minimal_d_separator(G, u, v, z):
 
     References
     ----------
-    .. [1] Tian, J., & Paz, A. (1998). Finding Minimal D-separators.
+    .. [1] van der Zander, Benito, and Maciej Liśkiewicz. "Finding
+        minimal d-separators in linear time and applications." In
+        Uncertainty in Artificial Intelligence, pp. 637-647. PMLR, 2020.
 
     Notes
     -----
-    This function only works on verifying a d-separating set is minimal
-    between two nodes. To verify that a d-separating set is minimal between
-    two sets of nodes is not supported.
-
-    Uses algorithm 2 presented in [1]_. The complexity of the algorithm
-    is :math:`O(|E_{An}^m|)`, where :math:`|E_{An}^m|` stands for the
-    number of edges in the moralized graph of the sub-graph consisting
-    of only the ancestors of ``u`` and ``v``.
-
-    The algorithm works by constructing the moral graph consisting of just
-    the ancestors of `u` and `v`. First, it performs BFS on the moral graph
-    starting from `u` and marking any nodes it encounters that are part of
-    the separating set, `z`. If a node is marked, then it does not continue
-    along that path. In the second stage, BFS with markings is repeated on the
-    moral graph starting from `v`. If at any stage, any node in `z` is
-    not marked, then `z` is considered not minimal. If the end of the algorithm
-    is reached, then `z` is minimal.
+    This function works on verifying that a set is minimal and
+    d-separating between two nodes. Uses criterion (a), (b), (c) on
+    page 4 of [1]_. a) closure(`x`) and `y` are disjoint. b) `z` contains
+    all nodes from `included` and is contained in the `restricted`
+    nodes and in the union of ancestors of `x`, `y`, and `included`.
+    c) the nodes in `z` not in `included` are contained in both
+    closure(x) and closure(y). The closure of a set is the set of nodes
+    connected to the set by a directed path in G.
+
+    The complexity is :math:`O(m)`, where :math:`m` stands for the
+    number of edges in the subgraph of G consisting of only the
+    ancestors of `x` and `y`.
 
     For full details, see [1]_.
-
-    https://en.wikipedia.org/wiki/Bayesian_network#d-separation
     """
-    if not nx.d_separated(G, {u}, {v}, z):
-        return False
-
-    x_anc = nx.ancestors(G, u)
-    y_anc = nx.ancestors(G, v)
-    xy_anc = x_anc.union(y_anc)
+    if not nx.is_directed_acyclic_graph(G):
+        raise nx.NetworkXError("graph should be directed acyclic")
 
-    # if Z contains any node which is not in ancestors of X or Y
-    # then it is definitely not minimal
-    if any(node not in xy_anc for node in z):
+    try:
+        x = {x} if x in G else x
+        y = {y} if y in G else y
+        z = {z} if z in G else z
+
+        if included is None:
+            included = set()
+        elif included in G:
+            included = {included}
+
+        if restricted is None:
+            restricted = set(G)
+        elif restricted in G:
+            restricted = {restricted}
+
+        set_y = x | y | included | restricted
+        if set_y - G.nodes:
+            raise nx.NodeNotFound(f"The node(s) {set_y - G.nodes} are not found in G")
+    except TypeError:
+        raise nx.NodeNotFound(
+            "One of x, y, z, included or restricted is not a node or set of nodes in G"
+        )
+
+    if not included <= z:
+        raise nx.NetworkXError(
+            f"Included nodes {included} must be in proposed separating set z {x}"
+        )
+    if not z <= restricted:
+        raise nx.NetworkXError(
+            f"Separating set {z} must be contained in restricted set {restricted}"
+        )
+
+    intersection = x.intersection(y) or x.intersection(z) or y.intersection(z)
+    if intersection:
+        raise nx.NetworkXError(
+            f"The sets are not disjoint, with intersection {intersection}"
+        )
+
+    nodeset = x | y | included
+    ancestors_x_y_included = nodeset.union(*[nx.ancestors(G, n) for n in nodeset])
+
+    # criterion (a) -- check that z is actually a separator
+    x_closure = _reachable(G, x, ancestors_x_y_included, z)
+    if x_closure & y:
         return False
 
-    D_anc_xy = x_anc.union(y_anc)
-    D_anc_xy.update((u, v))
-
-    # second, construct the moralization of the subgraph
-    moral_G = nx.moral_graph(G.subgraph(D_anc_xy))
-
-    # start BFS from X
-    marks = _bfs_with_marks(moral_G, u, z)
-
-    # if not all the Z is marked, then the set is not minimal
-    if any(node not in marks for node in z):
+    # criterion (b) -- basic constraint; included and restricted already checked above
+    if not (z <= ancestors_x_y_included):
         return False
 
-    # similarly, start BFS from Y and check the marks
-    marks = _bfs_with_marks(moral_G, v, z)
-    # if not all the Z is marked, then the set is not minimal
-    if any(node not in marks for node in z):
+    # criterion (c) -- check that z is minimal
+    y_closure = _reachable(G, y, ancestors_x_y_included, z)
+    if not ((z - included) <= (x_closure & y_closure)):
         return False
-
     return True
 
 
-@not_implemented_for("directed")
-def _bfs_with_marks(G, start_node, check_set):
-    """Breadth-first-search with markings.
+@not_implemented_for("undirected")
+def _reachable(G, x, a, z):
+    """Modified Bayes-Ball algorithm for finding d-connected nodes.
 
-    Performs BFS starting from ``start_node`` and whenever a node
-    inside ``check_set`` is met, it is "marked". Once a node is marked,
-    BFS does not continue along that path. The resulting marked nodes
-    are returned.
+    Find all nodes in `a` that are d-connected to those in `x` by
+    those in `z`. This is an implementation of the function
+    `REACHABLE` in [1]_ (which is itself a modification of the
+    Bayes-Ball algorithm [2]_) when restricted to DAGs.
 
     Parameters
     ----------
-    G : nx.Graph
-        An undirected graph.
-    start_node : node
-        The start of the BFS.
-    check_set : set
-        The set of nodes to check against.
+    G : nx.DiGraph
+        A NetworkX DAG.
+    x : node | set
+        A node in the DAG, or a set of nodes.
+    a : node | set
+        A (set of) node(s) in the DAG containing the ancestors of `x`.
+    z : node | set
+        The node or set of nodes conditioned on when checking d-connectedness.
 
     Returns
     -------
-    marked : set
-        A set of nodes that were marked.
+    w : set
+        The closure of `x` in `a` with respect to d-connectedness
+        given `z`.
+
+    References
+    ----------
+    .. [1] van der Zander, Benito, and Maciej Liśkiewicz. "Finding
+        minimal d-separators in linear time and applications." In
+        Uncertainty in Artificial Intelligence, pp. 637-647. PMLR, 2020.
+
+    .. [2] Shachter, Ross D. "Bayes-ball: The rational pastime
+       (for determining irrelevance and requisite information in
+       belief networks and influence diagrams)." In Proceedings of the
+       Fourteenth Conference on Uncertainty in Artificial Intelligence
+       (UAI), (pp. 480–487). 1998.
+    """
+
+    def _pass(e, v, f, n):
+        """Whether a ball entering node `v` along edge `e` passes to `n` along `f`.
+
+        Boolean function defined on page 6 of [1]_.
+
+        Parameters
+        ----------
+        e : bool
+            Directed edge by which the ball got to node `v`; `True` iff directed into `v`.
+        v : node
+            Node where the ball is.
+        f : bool
+            Directed edge connecting nodes `v` and `n`; `True` iff directed `n`.
+        n : node
+            Checking whether the ball passes to this node.
+
+        Returns
+        -------
+        b : bool
+            Whether the ball passes or not.
+
+        References
+        ----------
+        .. [1] van der Zander, Benito, and Maciej Liśkiewicz. "Finding
+           minimal d-separators in linear time and applications." In
+           Uncertainty in Artificial Intelligence, pp. 637-647. PMLR, 2020.
+        """
+        is_element_of_A = n in a
+        # almost_definite_status = True  # always true for DAGs; not so for RCGs
+        collider_if_in_Z = v not in z or (e and not f)
+        return is_element_of_A and collider_if_in_Z  # and almost_definite_status
+
+    queue = deque([])
+    for node in x:
+        if bool(G.pred[node]):
+            queue.append((True, node))
+        if bool(G.succ[node]):
+            queue.append((False, node))
+    processed = queue.copy()
+
+    while any(queue):
+        e, v = queue.popleft()
+        preds = ((False, n) for n in G.pred[v])
+        succs = ((True, n) for n in G.succ[v])
+        f_n_pairs = chain(preds, succs)
+        for f, n in f_n_pairs:
+            if (f, n) not in processed and _pass(e, v, f, n):
+                queue.append((f, n))
+                processed.append((f, n))
+
+    return {w for (_, w) in processed}
+
+
+# Deprecated functions:
+def d_separated(G, x, y, z):
+    """Return whether nodes sets ``x`` and ``y`` are d-separated by ``z``.
+
+    .. deprecated:: 3.3
+
+        This function is deprecated and will be removed in NetworkX v3.5.
+        Please use `is_d_separator(G, x, y, z)`.
+
+    """
+    import warnings
+
+    warnings.warn(
+        "d_separated is deprecated and will be removed in NetworkX v3.5."
+        "Please use `is_d_separator(G, x, y, z)`.",
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+    return nx.is_d_separator(G, x, y, z)
+
+
+def minimal_d_separator(G, u, v):
+    """Returns a minimal_d-separating set between `x` and `y` if possible
+
+    .. deprecated:: 3.3
+
+        minimal_d_separator is deprecated and will be removed in NetworkX v3.5.
+        Please use `find_minimal_d_separator(G, x, y)`.
+
     """
-    visited = {}
-    marked = set()
-    queue = []
-
-    visited[start_node] = None
-    queue.append(start_node)
-    while queue:
-        m = queue.pop(0)
-
-        for nbr in G.neighbors(m):
-            if nbr not in visited:
-                # memoize where we visited so far
-                visited[nbr] = None
-
-                # mark the node in Z' and do not continue along that path
-                if nbr in check_set:
-                    marked.add(nbr)
-                else:
-                    queue.append(nbr)
-    return marked
+    import warnings
+
+    warnings.warn(
+        (
+            "This function is deprecated and will be removed in NetworkX v3.5."
+            "Please use `is_d_separator(G, x, y)`."
+        ),
+        category=DeprecationWarning,
+        stacklevel=2,
+    )
+    return nx.find_minimal_d_separator(G, u, v)
diff --git a/networkx/algorithms/tests/test_d_separation.py b/networkx/algorithms/tests/test_d_separation.py
index a94d4dd4cfb..6f62971301b 100644
--- a/networkx/algorithms/tests/test_d_separation.py
+++ b/networkx/algorithms/tests/test_d_separation.py
@@ -81,6 +81,41 @@ def asia_graph_fixture():
     return asia_graph()
 
 
+@pytest.fixture()
+def large_collider_graph():
+    edge_list = [("A", "B"), ("C", "B"), ("B", "D"), ("D", "E"), ("B", "F"), ("G", "E")]
+    G = nx.DiGraph(edge_list)
+    return G
+
+
+@pytest.fixture()
+def chain_and_fork_graph():
+    edge_list = [("A", "B"), ("B", "C"), ("B", "D"), ("D", "C")]
+    G = nx.DiGraph(edge_list)
+    return G
+
+
+@pytest.fixture()
+def no_separating_set_graph():
+    edge_list = [("A", "B")]
+    G = nx.DiGraph(edge_list)
+    return G
+
+
+@pytest.fixture()
+def large_no_separating_set_graph():
+    edge_list = [("A", "B"), ("C", "A"), ("C", "B")]
+    G = nx.DiGraph(edge_list)
+    return G
+
+
+@pytest.fixture()
+def collider_trek_graph():
+    edge_list = [("A", "B"), ("C", "B"), ("C", "D")]
+    G = nx.DiGraph(edge_list)
+    return G
+
+
 @pytest.mark.parametrize(
     "graph",
     [path_graph(), fork_graph(), collider_graph(), naive_bayes_graph(), asia_graph()],
@@ -90,40 +125,40 @@ def test_markov_condition(graph):
     for node in graph.nodes:
         parents = set(graph.predecessors(node))
         non_descendants = graph.nodes - nx.descendants(graph, node) - {node} - parents
-        assert nx.d_separated(graph, {node}, non_descendants, parents)
+        assert nx.is_d_separator(graph, {node}, non_descendants, parents)
 
 
 def test_path_graph_dsep(path_graph):
     """Example-based test of d-separation for path_graph."""
-    assert nx.d_separated(path_graph, {0}, {2}, {1})
-    assert not nx.d_separated(path_graph, {0}, {2}, {})
+    assert nx.is_d_separator(path_graph, {0}, {2}, {1})
+    assert not nx.is_d_separator(path_graph, {0}, {2}, set())
 
 
 def test_fork_graph_dsep(fork_graph):
     """Example-based test of d-separation for fork_graph."""
-    assert nx.d_separated(fork_graph, {1}, {2}, {0})
-    assert not nx.d_separated(fork_graph, {1}, {2}, {})
+    assert nx.is_d_separator(fork_graph, {1}, {2}, {0})
+    assert not nx.is_d_separator(fork_graph, {1}, {2}, set())
 
 
 def test_collider_graph_dsep(collider_graph):
     """Example-based test of d-separation for collider_graph."""
-    assert nx.d_separated(collider_graph, {0}, {1}, {})
-    assert not nx.d_separated(collider_graph, {0}, {1}, {2})
+    assert nx.is_d_separator(collider_graph, {0}, {1}, set())
+    assert not nx.is_d_separator(collider_graph, {0}, {1}, {2})
 
 
 def test_naive_bayes_dsep(naive_bayes_graph):
     """Example-based test of d-separation for naive_bayes_graph."""
     for u, v in combinations(range(1, 5), 2):
-        assert nx.d_separated(naive_bayes_graph, {u}, {v}, {0})
-        assert not nx.d_separated(naive_bayes_graph, {u}, {v}, {})
+        assert nx.is_d_separator(naive_bayes_graph, {u}, {v}, {0})
+        assert not nx.is_d_separator(naive_bayes_graph, {u}, {v}, set())
 
 
 def test_asia_graph_dsep(asia_graph):
     """Example-based test of d-separation for asia_graph."""
-    assert nx.d_separated(
+    assert nx.is_d_separator(
         asia_graph, {"asia", "smoking"}, {"dyspnea", "xray"}, {"bronchitis", "either"}
     )
-    assert nx.d_separated(
+    assert nx.is_d_separator(
         asia_graph, {"tuberculosis", "cancer"}, {"bronchitis"}, {"smoking", "xray"}
     )
 
@@ -137,11 +172,11 @@ def test_undirected_graphs_are_not_supported():
     """
     g = nx.path_graph(3, nx.Graph)
     with pytest.raises(nx.NetworkXNotImplemented):
-        nx.d_separated(g, {0}, {1}, {2})
+        nx.is_d_separator(g, {0}, {1}, {2})
     with pytest.raises(nx.NetworkXNotImplemented):
         nx.is_minimal_d_separator(g, {0}, {1}, {2})
     with pytest.raises(nx.NetworkXNotImplemented):
-        nx.minimal_d_separator(g, {0}, {1})
+        nx.find_minimal_d_separator(g, {0}, {1})
 
 
 def test_cyclic_graphs_raise_error():
@@ -152,60 +187,128 @@ def test_cyclic_graphs_raise_error():
     """
     g = nx.cycle_graph(3, nx.DiGraph)
     with pytest.raises(nx.NetworkXError):
-        nx.d_separated(g, {0}, {1}, {2})
+        nx.is_d_separator(g, {0}, {1}, {2})
     with pytest.raises(nx.NetworkXError):
-        nx.minimal_d_separator(g, 0, 1)
+        nx.find_minimal_d_separator(g, {0}, {1})
     with pytest.raises(nx.NetworkXError):
-        nx.is_minimal_d_separator(g, 0, 1, {2})
+        nx.is_minimal_d_separator(g, {0}, {1}, {2})
 
 
 def test_invalid_nodes_raise_error(asia_graph):
     """
     Test that graphs that have invalid nodes passed in raise errors.
     """
+    # Check both set and node arguments
+    with pytest.raises(nx.NodeNotFound):
+        nx.is_d_separator(asia_graph, {0}, {1}, {2})
+    with pytest.raises(nx.NodeNotFound):
+        nx.is_d_separator(asia_graph, 0, 1, 2)
+    with pytest.raises(nx.NodeNotFound):
+        nx.is_minimal_d_separator(asia_graph, {0}, {1}, {2})
     with pytest.raises(nx.NodeNotFound):
-        nx.d_separated(asia_graph, {0}, {1}, {2})
+        nx.is_minimal_d_separator(asia_graph, 0, 1, 2)
     with pytest.raises(nx.NodeNotFound):
-        nx.is_minimal_d_separator(asia_graph, 0, 1, {2})
+        nx.find_minimal_d_separator(asia_graph, {0}, {1})
     with pytest.raises(nx.NodeNotFound):
-        nx.minimal_d_separator(asia_graph, 0, 1)
+        nx.find_minimal_d_separator(asia_graph, 0, 1)
 
 
-def test_minimal_d_separator():
+def test_nondisjoint_node_sets_raise_error(collider_graph):
+    """
+    Test that error is raised when node sets aren't disjoint.
+    """
+    with pytest.raises(nx.NetworkXError):
+        nx.is_d_separator(collider_graph, 0, 1, 0)
+    with pytest.raises(nx.NetworkXError):
+        nx.is_d_separator(collider_graph, 0, 2, 0)
+    with pytest.raises(nx.NetworkXError):
+        nx.is_d_separator(collider_graph, 0, 0, 1)
+    with pytest.raises(nx.NetworkXError):
+        nx.is_d_separator(collider_graph, 1, 0, 0)
+    with pytest.raises(nx.NetworkXError):
+        nx.find_minimal_d_separator(collider_graph, 0, 0)
+    with pytest.raises(nx.NetworkXError):
+        nx.find_minimal_d_separator(collider_graph, 0, 1, included=0)
+    with pytest.raises(nx.NetworkXError):
+        nx.find_minimal_d_separator(collider_graph, 1, 0, included=0)
+    with pytest.raises(nx.NetworkXError):
+        nx.is_minimal_d_separator(collider_graph, 0, 0, set())
+    with pytest.raises(nx.NetworkXError):
+        nx.is_minimal_d_separator(collider_graph, 0, 1, set(), included=0)
+    with pytest.raises(nx.NetworkXError):
+        nx.is_minimal_d_separator(collider_graph, 1, 0, set(), included=0)
+
+
+def test_is_minimal_d_separator(
+    large_collider_graph,
+    chain_and_fork_graph,
+    no_separating_set_graph,
+    large_no_separating_set_graph,
+    collider_trek_graph,
+):
     # Case 1:
     # create a graph A -> B <- C
     # B -> D -> E;
     # B -> F;
     # G -> E;
-    edge_list = [("A", "B"), ("C", "B"), ("B", "D"), ("D", "E"), ("B", "F"), ("G", "E")]
-    G = nx.DiGraph(edge_list)
-    assert not nx.d_separated(G, {"B"}, {"E"}, set())
+    assert not nx.is_d_separator(large_collider_graph, {"B"}, {"E"}, set())
 
     # minimal set of the corresponding graph
     # for B and E should be (D,)
-    Zmin = nx.minimal_d_separator(G, "B", "E")
-
-    # the minimal separating set should pass the test for minimality
-    assert nx.is_minimal_d_separator(G, "B", "E", Zmin)
+    Zmin = nx.find_minimal_d_separator(large_collider_graph, "B", "E")
+    # check that the minimal d-separator is a d-separating set
+    assert nx.is_d_separator(large_collider_graph, "B", "E", Zmin)
+    # the minimal separating set should also pass the test for minimality
+    assert nx.is_minimal_d_separator(large_collider_graph, "B", "E", Zmin)
+    # function should also work with set arguments
+    assert nx.is_minimal_d_separator(large_collider_graph, {"A", "B"}, {"G", "E"}, Zmin)
     assert Zmin == {"D"}
 
     # Case 2:
     # create a graph A -> B -> C
     # B -> D -> C;
-    edge_list = [("A", "B"), ("B", "C"), ("B", "D"), ("D", "C")]
-    G = nx.DiGraph(edge_list)
-    assert not nx.d_separated(G, {"A"}, {"C"}, set())
-    Zmin = nx.minimal_d_separator(G, "A", "C")
+    assert not nx.is_d_separator(chain_and_fork_graph, {"A"}, {"C"}, set())
+    Zmin = nx.find_minimal_d_separator(chain_and_fork_graph, "A", "C")
 
     # the minimal separating set should pass the test for minimality
-    assert nx.is_minimal_d_separator(G, "A", "C", Zmin)
+    assert nx.is_minimal_d_separator(chain_and_fork_graph, "A", "C", Zmin)
     assert Zmin == {"B"}
-
     Znotmin = Zmin.union({"D"})
-    assert not nx.is_minimal_d_separator(G, "A", "C", Znotmin)
+    assert not nx.is_minimal_d_separator(chain_and_fork_graph, "A", "C", Znotmin)
+
+    # Case 3:
+    # create a graph A -> B
+
+    # there is no m-separating set between A and B at all, so
+    # no minimal m-separating set can exist
+    assert not nx.is_d_separator(no_separating_set_graph, {"A"}, {"B"}, set())
+    assert nx.find_minimal_d_separator(no_separating_set_graph, "A", "B") is None
+
+    # Case 4:
+    # create a graph A -> B with A <- C -> B
+
+    # there is no m-separating set between A and B at all, so
+    # no minimal m-separating set can exist
+    # however, the algorithm will initially propose C as a
+    # minimal (but invalid) separating set
+    assert not nx.is_d_separator(large_no_separating_set_graph, {"A"}, {"B"}, {"C"})
+    assert nx.find_minimal_d_separator(large_no_separating_set_graph, "A", "B") is None
+
+    # Test `included` and `excluded` args
+    # create graph A -> B <- C -> D
+    assert nx.find_minimal_d_separator(collider_trek_graph, "A", "D", included="B") == {
+        "B",
+        "C",
+    }
+    assert (
+        nx.find_minimal_d_separator(
+            collider_trek_graph, "A", "D", included="B", restricted="B"
+        )
+        is None
+    )
 
 
-def test_minimal_d_separator_checks_dsep():
+def test_is_minimal_d_separator_checks_dsep():
     """Test that is_minimal_d_separator checks for d-separation as well."""
     g = nx.DiGraph()
     g.add_edges_from(
@@ -221,8 +324,25 @@ def test_minimal_d_separator_checks_dsep():
         ]
     )
 
-    assert not nx.d_separated(g, {"C"}, {"F"}, {"D"})
+    assert not nx.is_d_separator(g, {"C"}, {"F"}, {"D"})
 
     # since {'D'} and {} are not d-separators, we return false
     assert not nx.is_minimal_d_separator(g, "C", "F", {"D"})
-    assert not nx.is_minimal_d_separator(g, "C", "F", {})
+    assert not nx.is_minimal_d_separator(g, "C", "F", set())
+
+
+def test__reachable(large_collider_graph):
+    reachable = nx.algorithms.d_separation._reachable
+    g = large_collider_graph
+    x = {"F", "D"}
+    ancestors = {"A", "B", "C", "D", "F"}
+    assert reachable(g, x, ancestors, {"B"}) == {"B", "F", "D"}
+    assert reachable(g, x, ancestors, set()) == ancestors
+
+
+def test_deprecations():
+    G = nx.DiGraph([(0, 1), (1, 2)])
+    with pytest.deprecated_call():
+        nx.d_separated(G, 0, 2, {1})
+    with pytest.deprecated_call():
+        z = nx.minimal_d_separator(G, 0, 2)
diff --git a/networkx/conftest.py b/networkx/conftest.py
index 41f4789c330..9a25495d580 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -133,6 +133,12 @@ def set_warnings():
     warnings.filterwarnings(
         "ignore", category=DeprecationWarning, message="\n\nrandom_triad"
     )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="minimal_d_separator"
+    )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="d_separated"
+    )
     warnings.filterwarnings("ignore", category=DeprecationWarning, message="\n\nk_core")
     warnings.filterwarnings(
         "ignore", category=DeprecationWarning, message="\n\nk_shell"

From 1168afca385dab8cbda8be3aa479a22581e94988 Mon Sep 17 00:00:00 2001
From: Navya Agarwal <82928853+navyagarwal@users.noreply.github.com>
Date: Fri, 22 Dec 2023 20:05:16 +0530
Subject: [PATCH 019/129] Fix all_node_cuts output for complete graphs (#6558)

* Fix for complete graphs case in all_node_cuts

* Check node_connectivty in complete graph

* test for broken cuts. add fix

---------

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/connectivity/kcutsets.py    |  7 ++++---
 .../connectivity/tests/test_kcutsets.py         | 17 ++++++++++++-----
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/networkx/algorithms/connectivity/kcutsets.py b/networkx/algorithms/connectivity/kcutsets.py
index bc04ed18589..f2036faf1e1 100644
--- a/networkx/algorithms/connectivity/kcutsets.py
+++ b/networkx/algorithms/connectivity/kcutsets.py
@@ -93,10 +93,11 @@ def all_node_cuts(G, k=None, flow_func=None):
 
     # Address some corner cases first.
     # For complete Graphs
+
     if nx.density(G) == 1:
-        for cut_set in combinations(G, len(G) - 1):
-            yield set(cut_set)
+        yield from ()
         return
+
     # Initialize data structures.
     # Keep track of the cuts already computed so we do not repeat them.
     seen = []
@@ -130,7 +131,7 @@ def all_node_cuts(G, k=None, flow_func=None):
     for x in X:
         # step 3: Compute local connectivity flow of x with all other
         # non adjacent nodes in G
-        non_adjacent = set(G) - X - set(G[x])
+        non_adjacent = set(G) - {x} - set(G[x])
         for v in non_adjacent:
             # step 4: compute maximum flow in an Even-Tarjan reduction H of G
             # and step 5: build the associated residual network R
diff --git a/networkx/algorithms/connectivity/tests/test_kcutsets.py b/networkx/algorithms/connectivity/tests/test_kcutsets.py
index d5b3b089e23..4b4b5494a87 100644
--- a/networkx/algorithms/connectivity/tests/test_kcutsets.py
+++ b/networkx/algorithms/connectivity/tests/test_kcutsets.py
@@ -259,8 +259,15 @@ def test_cycle_graph():
 
 def test_complete_graph():
     G = nx.complete_graph(5)
-    solution = [{0, 1, 2, 3}, {0, 1, 2, 4}, {0, 1, 3, 4}, {0, 2, 3, 4}, {1, 2, 3, 4}]
-    cuts = list(nx.all_node_cuts(G))
-    assert len(solution) == len(cuts)
-    for cut in cuts:
-        assert cut in solution
+    assert nx.node_connectivity(G) == 4
+    assert list(nx.all_node_cuts(G)) == []
+
+
+def test_all_node_cuts_simple_case():
+    G = nx.complete_graph(5)
+    G.remove_edges_from([(0, 1), (3, 4)])
+    expected = [{0, 1, 2}, {2, 3, 4}]
+    actual = list(nx.all_node_cuts(G))
+    assert len(actual) == len(expected)
+    for cut in actual:
+        assert cut in expected

From 0762b7f30d1e315dc8c10029a59cf73148446ea2 Mon Sep 17 00:00:00 2001
From: Sadra Barikbin <sadraqazvin1@yahoo.com>
Date: Sat, 30 Dec 2023 18:59:15 +0330
Subject: [PATCH 020/129] Fix a tiny typo in
 `structuralholes.py::local_constraint` docstring (#7198)

Update structuralholes.py

Fix a tiny typo in local_constraint docstring.
---
 networkx/algorithms/structuralholes.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/networkx/algorithms/structuralholes.py b/networkx/algorithms/structuralholes.py
index c676177b38e..6d4f33171dd 100644
--- a/networkx/algorithms/structuralholes.py
+++ b/networkx/algorithms/structuralholes.py
@@ -229,7 +229,7 @@ def local_constraint(G, u, v, weight=None):
     the node ``v`` in the graph ``G``.
 
     Formally, the *local constraint on u with respect to v*, denoted
-    $\ell(v)$, is defined by
+    $\ell(u, v)$, is defined by
 
     .. math::
 

From 6109e10c31f2c9beb7e3370cca26af6878acf222 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Sat, 30 Dec 2023 21:10:27 +0530
Subject: [PATCH 021/129] Added `subgraph_is_monomorphic` and
 `subgraph_monomorphisms_iter` in docs (#7197)

issue7170
---
 doc/reference/algorithms/isomorphism.vf2.rst | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/doc/reference/algorithms/isomorphism.vf2.rst b/doc/reference/algorithms/isomorphism.vf2.rst
index a5c2ad4206d..95b62de661a 100644
--- a/doc/reference/algorithms/isomorphism.vf2.rst
+++ b/doc/reference/algorithms/isomorphism.vf2.rst
@@ -17,8 +17,10 @@ Graph Matcher
     GraphMatcher.initialize
     GraphMatcher.is_isomorphic
     GraphMatcher.subgraph_is_isomorphic
+    GraphMatcher.subgraph_is_monomorphic
     GraphMatcher.isomorphisms_iter
     GraphMatcher.subgraph_isomorphisms_iter
+    GraphMatcher.subgraph_monomorphisms_iter
     GraphMatcher.candidate_pairs_iter
     GraphMatcher.match
     GraphMatcher.semantic_feasibility
@@ -36,8 +38,10 @@ DiGraph Matcher
     DiGraphMatcher.initialize
     DiGraphMatcher.is_isomorphic
     DiGraphMatcher.subgraph_is_isomorphic
+    DiGraphMatcher.subgraph_is_monomorphic
     DiGraphMatcher.isomorphisms_iter
     DiGraphMatcher.subgraph_isomorphisms_iter
+    DiGraphMatcher.subgraph_monomorphisms_iter
     DiGraphMatcher.candidate_pairs_iter
     DiGraphMatcher.match
     DiGraphMatcher.semantic_feasibility

From e755ea77eef9a6325d8f3edfbea959a3dd96ae72 Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Tue, 2 Jan 2024 07:06:36 -0600
Subject: [PATCH 022/129] Fix online docs for `_dispatch` (#7194)

* Fix online docs for `_dispatch`

* whatcha talkin bout mypy?
---
 networkx/utils/backends.py | 121 +++++++++++++++++++------------------
 1 file changed, 63 insertions(+), 58 deletions(-)

diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index c2d5661e034..57935640198 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -146,64 +146,6 @@ def _load_backend(backend_name):
 
 
 class _dispatch:
-    """Dispatches to a backend algorithm based on input graph types.
-
-    Parameters
-    ----------
-    func : function
-
-    name : str, optional
-        The name of the algorithm to use for dispatching. If not provided,
-        the name of ``func`` will be used. ``name`` is useful to avoid name
-        conflicts, as all dispatched algorithms live in a single namespace.
-
-    graphs : str or dict or None, default "G"
-        If a string, the parameter name of the graph, which must be the first
-        argument of the wrapped function. If more than one graph is required
-        for the algorithm (or if the graph is not the first argument), provide
-        a dict of parameter name to argument position for each graph argument.
-        For example, ``@_dispatch(graphs={"G": 0, "auxiliary?": 4})``
-        indicates the 0th parameter ``G`` of the function is a required graph,
-        and the 4th parameter ``auxiliary`` is an optional graph.
-        To indicate an argument is a list of graphs, do e.g. ``"[graphs]"``.
-        Use ``graphs=None`` if *no* arguments are NetworkX graphs such as for
-        graph generators, readers, and conversion functions.
-
-    edge_attrs : str or dict, optional
-        ``edge_attrs`` holds information about edge attribute arguments
-        and default values for those edge attributes.
-        If a string, ``edge_attrs`` holds the function argument name that
-        indicates a single edge attribute to include in the converted graph.
-        The default value for this attribute is 1. To indicate that an argument
-        is a list of attributes (all with default value 1), use e.g. ``"[attrs]"``.
-        If a dict, ``edge_attrs`` holds a dict keyed by argument names, with
-        values that are either the default value or, if a string, the argument
-        name that indicates the default value.
-
-    node_attrs : str or dict, optional
-        Like ``edge_attrs``, but for node attributes.
-
-    preserve_edge_attrs : bool or str or dict, optional
-        For bool, whether to preserve all edge attributes.
-        For str, the parameter name that may indicate (with ``True`` or a
-        callable argument) whether all edge attributes should be preserved
-        when converting.
-        For dict of ``{graph_name: {attr: default}}``, indicate pre-determined
-        edge attributes (and defaults) to preserve for input graphs.
-
-    preserve_node_attrs : bool or str or dict, optional
-        Like ``preserve_edge_attrs``, but for node attributes.
-
-    preserve_graph_attrs : bool or set
-        For bool, whether to preserve all graph attributes.
-        For set, which input graph arguments to preserve graph attributes.
-
-    preserve_all_attrs : bool
-        Whether to preserve all edge, node and graph attributes.
-        This overrides all the other preserve_*_attrs.
-
-    """
-
     # Allow any of the following decorator forms:
     #  - @_dispatch
     #  - @_dispatch()
@@ -238,6 +180,63 @@ def __new__(
         preserve_graph_attrs=False,
         preserve_all_attrs=False,
     ):
+        """Dispatches to a backend algorithm based on input graph types.
+
+        Parameters
+        ----------
+        func : function
+
+        name : str, optional
+            The name of the algorithm to use for dispatching. If not provided,
+            the name of ``func`` will be used. ``name`` is useful to avoid name
+            conflicts, as all dispatched algorithms live in a single namespace.
+
+        graphs : str or dict or None, default "G"
+            If a string, the parameter name of the graph, which must be the first
+            argument of the wrapped function. If more than one graph is required
+            for the algorithm (or if the graph is not the first argument), provide
+            a dict of parameter name to argument position for each graph argument.
+            For example, ``@_dispatch(graphs={"G": 0, "auxiliary?": 4})``
+            indicates the 0th parameter ``G`` of the function is a required graph,
+            and the 4th parameter ``auxiliary`` is an optional graph.
+            To indicate an argument is a list of graphs, do e.g. ``"[graphs]"``.
+            Use ``graphs=None`` if *no* arguments are NetworkX graphs such as for
+            graph generators, readers, and conversion functions.
+
+        edge_attrs : str or dict, optional
+            ``edge_attrs`` holds information about edge attribute arguments
+            and default values for those edge attributes.
+            If a string, ``edge_attrs`` holds the function argument name that
+            indicates a single edge attribute to include in the converted graph.
+            The default value for this attribute is 1. To indicate that an argument
+            is a list of attributes (all with default value 1), use e.g. ``"[attrs]"``.
+            If a dict, ``edge_attrs`` holds a dict keyed by argument names, with
+            values that are either the default value or, if a string, the argument
+            name that indicates the default value.
+
+        node_attrs : str or dict, optional
+            Like ``edge_attrs``, but for node attributes.
+
+        preserve_edge_attrs : bool or str or dict, optional
+            For bool, whether to preserve all edge attributes.
+            For str, the parameter name that may indicate (with ``True`` or a
+            callable argument) whether all edge attributes should be preserved
+            when converting.
+            For dict of ``{graph_name: {attr: default}}``, indicate pre-determined
+            edge attributes (and defaults) to preserve for input graphs.
+
+        preserve_node_attrs : bool or str or dict, optional
+            Like ``preserve_edge_attrs``, but for node attributes.
+
+        preserve_graph_attrs : bool or set
+            For bool, whether to preserve all graph attributes.
+            For set, which input graph arguments to preserve graph attributes.
+
+        preserve_all_attrs : bool
+            Whether to preserve all edge, node and graph attributes.
+            This overrides all the other preserve_*_attrs.
+
+        """
         if func is None:
             return partial(
                 _dispatch,
@@ -1016,3 +1015,9 @@ def _dispatch(func=None, **kwargs):  # type: ignore[no-redef]
         dispatched_func = _orig_dispatch(func, **kwargs)
         func.__doc__ = dispatched_func.__doc__
         return func
+
+    _dispatch.__doc__ = _orig_dispatch.__new__.__doc__  # type: ignore[method-assign,assignment]
+    _sig = inspect.signature(_orig_dispatch.__new__)
+    _dispatch.__signature__ = _sig.replace(  # type: ignore[method-assign,assignment]
+        parameters=[v for k, v in _sig.parameters.items() if k != "cls"]
+    )

From 3a98973a942066ffaa300fba1d884d92eaee8128 Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Tue, 2 Jan 2024 07:07:51 -0600
Subject: [PATCH 023/129] Remove `"networkx.plugins"` and
 `"networkx.plugin_info"` entry-points (#7192)

Use `"networkx.backends"` and `"networkx.backend_info"` instead.
Version 3.2 supported both options. The next release can drop "plugin".
---
 networkx/utils/backends.py | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 57935640198..6c0e5649bd3 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -124,12 +124,8 @@ def _get_backends(group, *, load_and_call=False):
     return rv
 
 
-# Rename "plugin" to "backend", and give backends a release cycle to update.
-backends = _get_backends("networkx.plugins")
-backend_info = _get_backends("networkx.plugin_info", load_and_call=True)
-
-backends.update(_get_backends("networkx.backends"))
-backend_info.update(_get_backends("networkx.backend_info", load_and_call=True))
+backends = _get_backends("networkx.backends")
+backend_info = _get_backends("networkx.backend_info", load_and_call=True)
 
 # Load and cache backends on-demand
 _loaded_backends = {}  # type: ignore[var-annotated]

From ad92646029cee542bf6a9313fd7b093302a49aa2 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Tue, 2 Jan 2024 18:42:14 +0530
Subject: [PATCH 024/129] DOC : Updated docs for panther_similarity (#7175)

* DOC : Updated panther_similarity

* style fix

* removed eg

* Update similarity.py
---
 networkx/algorithms/similarity.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index 0ad6de6e6fe..ec222d23d8a 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -1532,7 +1532,7 @@ def panther_similarity(
     source : node
         Source node for which to find the top `k` similar other nodes
     k : int (default = 5)
-        The number of most similar nodes to return
+        The number of most similar nodes to return.
     path_length : int (default = 5)
         How long the randomly generated paths should be (``T`` in [1]_)
     c : float (default = 0.5)
@@ -1554,7 +1554,8 @@ def panther_similarity(
     similarity : dictionary
         Dictionary of nodes to similarity scores (as floats). Note:
         the self-similarity (i.e., ``v``) will not be included in
-        the returned dictionary.
+        the returned dictionary. So, for ``k = 5``, a dictionary of
+        top 4 nodes and their similarity scores will be returned.
 
     Raises
     -------

From 62288244a7356db0d7def7bd532d05457f567301 Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Tue, 2 Jan 2024 07:13:26 -0600
Subject: [PATCH 025/129] Fix warnings when building docs (#7195)

---
 doc/developer/projects.rst                     |  2 +-
 .../algorithms/community/label_propagation.py  | 18 +++++++++---------
 networkx/algorithms/distance_measures.py       |  2 +-
 networkx/algorithms/similarity.py              |  6 +++---
 networkx/classes/function.py                   |  2 +-
 networkx/generators/expanders.py               |  4 ++--
 6 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/doc/developer/projects.rst b/doc/developer/projects.rst
index 623a9986b8b..fbd3b4e2c51 100644
--- a/doc/developer/projects.rst
+++ b/doc/developer/projects.rst
@@ -89,7 +89,7 @@ Centrality Atlas
   of network centrality measures.
   Centrality is a central concept in network science and has many applications
   across domains. NetworkX provides many functions for measuring
-  various types of :doc:`network centrality<reference/algorithms/centrality>`.
+  various types of :doc:`network centrality</reference/algorithms/centrality>`.
   The individual centrality functions are typically well-described by their
   docstrings (though there's always room for improvement!); however, there
   currently is no big-picture overview of centrality.
diff --git a/networkx/algorithms/community/label_propagation.py b/networkx/algorithms/community/label_propagation.py
index 5d799d3de5c..307dfbe3a42 100644
--- a/networkx/algorithms/community/label_propagation.py
+++ b/networkx/algorithms/community/label_propagation.py
@@ -35,21 +35,21 @@ def fast_label_propagation_communities(G, *, weight=None, seed=None):
     Parameters
     ----------
     G : Graph, DiGraph, MultiGraph, or MultiDiGraph
-      Any NetworkX graph.
+        Any NetworkX graph.
 
     weight : string, or None (default)
-      The edge attribute representing a non-negative weight of an edge. If None,
-      each edge is assumed to have weight one. The weight of an edge is used in
-      determining the frequency with which a label appears among the neighbors of
-      a node (edge with weight `w` is equivalent to `w` unweighted edges).
+        The edge attribute representing a non-negative weight of an edge. If None,
+        each edge is assumed to have weight one. The weight of an edge is used in
+        determining the frequency with which a label appears among the neighbors of
+        a node (edge with weight `w` is equivalent to `w` unweighted edges).
 
     seed : integer, random_state, or None (default)
-      Indicator of random number generation state. See :ref:`Randomness<randomness>`.
+        Indicator of random number generation state. See :ref:`Randomness<randomness>`.
 
     Returns
     -------
     communities : iterable
-      Iterable of communities given as sets of nodes.
+        Iterable of communities given as sets of nodes.
 
     Notes
     -----
@@ -59,8 +59,8 @@ def fast_label_propagation_communities(G, *, weight=None, seed=None):
     References
     ----------
     .. [1] Vincent A. Traag & Lovro Šubelj. "Large network community detection by
-    fast label propagation." Scientific Reports 13 (2023): 2701.
-    https://doi.org/10.1038/s41598-023-29610-z
+       fast label propagation." Scientific Reports 13 (2023): 2701.
+       https://doi.org/10.1038/s41598-023-29610-z
     """
 
     # Queue of nodes to be processed.
diff --git a/networkx/algorithms/distance_measures.py b/networkx/algorithms/distance_measures.py
index 04f88b17b6a..844e85f335b 100644
--- a/networkx/algorithms/distance_measures.py
+++ b/networkx/algorithms/distance_measures.py
@@ -798,7 +798,7 @@ def effective_graph_resistance(G, weight=None, invert_weight=True):
         The effective graph resistance of `G`.
 
     Raises
-    -------
+    ------
     NetworkXNotImplemented
         If `G` is a directed graph.
 
diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index ec222d23d8a..3a1cfff8147 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -1276,7 +1276,7 @@ def simrank(G, u, v):
         the similarity value for the given pair of nodes.
 
     Raises
-    -------
+    ------
     ExceededMaxIterations
         If the algorithm does not converge within ``max_iterations``.
 
@@ -1558,7 +1558,7 @@ def panther_similarity(
         top 4 nodes and their similarity scores will be returned.
 
     Raises
-    -------
+    ------
     NetworkXUnfeasible
         If `source` is an isolated node.
 
@@ -1566,7 +1566,7 @@ def panther_similarity(
         If `source` is not in `G`.
 
     Notes
-    -------
+    -----
         The isolated nodes in `G` are ignored.
 
     Examples
diff --git a/networkx/classes/function.py b/networkx/classes/function.py
index 3f40eab1583..2746d56d715 100644
--- a/networkx/classes/function.py
+++ b/networkx/classes/function.py
@@ -80,7 +80,7 @@ def degree(G, nbunch=None, weight=None):
 def neighbors(G, n):
     """Returns an iterator over all neighbors of node n.
 
-    This function wraps the :func:``G.neighbors <networkx.Graph.neighbors>` function.
+    This function wraps the :func:`G.neighbors <networkx.Graph.neighbors>` function.
     """
     return G.neighbors(n)
 
diff --git a/networkx/generators/expanders.py b/networkx/generators/expanders.py
index efac382c35f..2385682be58 100644
--- a/networkx/generators/expanders.py
+++ b/networkx/generators/expanders.py
@@ -340,7 +340,7 @@ def is_regular_expander(G, *, epsilon=0):
     the Alon-Boppana bound and given by
     $\lambda = 2 \sqrt{d - 1} + \epsilon$. [2]_
 
-    In the case where $\epsilon = 0 $ then if the graph successfully passes the test
+    In the case where $\epsilon = 0$ then if the graph successfully passes the test
     it is a Ramanujan graph. [3]_
 
     A Ramanujan graph has spectral gap almost as large as possible, which makes them
@@ -404,7 +404,7 @@ def random_regular_expander_graph(n, d, *, epsilon=0, create_using=None, max_tri
     More precisely the returned graph is a $(n, d, \lambda)$-expander with
     $\lambda = 2 \sqrt{d - 1} + \epsilon$, close to the Alon-Boppana bound. [2]_
 
-    In the case where $\epsilon = 0 $ it returns a Ramanujan graph.
+    In the case where $\epsilon = 0$ it returns a Ramanujan graph.
     A Ramanujan graph has spectral gap almost as large as possible,
     which makes them excellent expanders. [3]_
 

From 3394571321815993d52d6e8c1c0ef062c6dedf0b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 3 Jan 2024 11:16:49 -0800
Subject: [PATCH 026/129] Bump actions/setup-python from 4 to 5 (#7201)

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 4 to 5.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/v4...v5)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/coverage.yml             |  2 +-
 .github/workflows/deploy-docs.yml          |  2 +-
 .github/workflows/lint.yml                 |  2 +-
 .github/workflows/mypy.yml                 |  2 +-
 .github/workflows/nightly-release-test.yml |  2 +-
 .github/workflows/nightly.yml              |  2 +-
 .github/workflows/pytest-randomly.yml      |  2 +-
 .github/workflows/release.yml              |  2 +-
 .github/workflows/test.yml                 | 10 +++++-----
 9 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 5b75cfbcfdc..a7ffdea017b 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -19,7 +19,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
index d26df0bed6e..1bc885907b3 100644
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -14,7 +14,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.11"
 
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 7f43b045f92..2634e5c1258 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -17,7 +17,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
diff --git a/.github/workflows/mypy.yml b/.github/workflows/mypy.yml
index a025509cb0a..156841681a5 100644
--- a/.github/workflows/mypy.yml
+++ b/.github/workflows/mypy.yml
@@ -17,7 +17,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
diff --git a/.github/workflows/nightly-release-test.yml b/.github/workflows/nightly-release-test.yml
index f9f1a8b7f25..94d9c38e689 100644
--- a/.github/workflows/nightly-release-test.yml
+++ b/.github/workflows/nightly-release-test.yml
@@ -14,7 +14,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index 43084700c25..b274f5c7f21 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: "3.10"
       - name: Install Python requirements
diff --git a/.github/workflows/pytest-randomly.yml b/.github/workflows/pytest-randomly.yml
index 162ad4189a2..683e630ad88 100644
--- a/.github/workflows/pytest-randomly.yml
+++ b/.github/workflows/pytest-randomly.yml
@@ -11,7 +11,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.10"
 
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index accb03ae86c..91724b5b8e4 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -19,7 +19,7 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         name: Install Python
         with:
           python-version: "3.11"
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 80d23aad3be..5d6b0113aff 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -16,7 +16,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -40,7 +40,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -66,7 +66,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -90,7 +90,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -150,7 +150,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 

From 73c655270ee22ae06b60c5a6c4a03d1fdf202fc2 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Thu, 4 Jan 2024 09:02:56 -0800
Subject: [PATCH 027/129] Update test suite for Pytest v8 (#7203)

* Rm deprecated_call filter from strongly connected raises test.

* Replace deprecated pytest.warns(None) with catch_warnings.
---
 .../algorithms/components/tests/test_strongly_connected.py     | 3 +--
 networkx/drawing/tests/test_agraph.py                          | 3 ++-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/networkx/algorithms/components/tests/test_strongly_connected.py b/networkx/algorithms/components/tests/test_strongly_connected.py
index 6d4ea855229..21d9e671898 100644
--- a/networkx/algorithms/components/tests/test_strongly_connected.py
+++ b/networkx/algorithms/components/tests/test_strongly_connected.py
@@ -183,8 +183,7 @@ def test_connected_raise(self):
         with pytest.raises(NetworkXNotImplemented):
             next(nx.kosaraju_strongly_connected_components(G))
         with pytest.raises(NetworkXNotImplemented):
-            with pytest.deprecated_call():
-                next(nx.strongly_connected_components_recursive(G))
+            next(nx.strongly_connected_components_recursive(G))
         pytest.raises(NetworkXNotImplemented, nx.is_strongly_connected, G)
         pytest.raises(NetworkXNotImplemented, nx.condensation, G)
 
diff --git a/networkx/drawing/tests/test_agraph.py b/networkx/drawing/tests/test_agraph.py
index 1ade719bc2b..fd99daaf757 100644
--- a/networkx/drawing/tests/test_agraph.py
+++ b/networkx/drawing/tests/test_agraph.py
@@ -1,6 +1,7 @@
 """Unit tests for PyGraphviz interface."""
 import os
 import tempfile
+import warnings
 
 import pytest
 
@@ -249,6 +250,6 @@ def test_no_warnings_raised(self):
         G.add_node(0, pos=(0, 0))
         G.add_node(1, pos=(1, 1))
         A = nx.nx_agraph.to_agraph(G)
-        with pytest.warns(None) as record:
+        with warnings.catch_warnings(record=True) as record:
             A.layout()
         assert len(record) == 0

From 5d2f19b876f4d73bbbee371c5279f48a4c615d23 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Thu, 4 Jan 2024 10:57:16 -0800
Subject: [PATCH 028/129] Undeprecate ``nx_pydot`` now that pydot is actively
 maintained again (#7204)

* Un-xfail pydot tests.

* Pin pydot minver to 2.0.

* Rm deprecation bullet from devdocs.

* Back out deprecation warnings for nx_pydot.

---------

Co-authored-by: Jarrod Millman <jarrod.millman@gmail.com>
---
 doc/developer/deprecations.rst       |  1 -
 networkx/conftest.py                 |  3 --
 networkx/drawing/nx_pydot.py         | 43 ----------------------------
 networkx/drawing/tests/test_pydot.py |  1 -
 pyproject.toml                       |  2 +-
 requirements/extra.txt               |  2 +-
 6 files changed, 2 insertions(+), 50 deletions(-)

diff --git a/doc/developer/deprecations.rst b/doc/developer/deprecations.rst
index 8dfbccdc7ca..fffe9ecef2f 100644
--- a/doc/developer/deprecations.rst
+++ b/doc/developer/deprecations.rst
@@ -43,7 +43,6 @@ Make sure to review ``networkx/conftest.py`` after removing deprecated code.
 
 Version 3.3
 ~~~~~~~~~~~
-* Remove pydot functionality ``drawing/nx_pydot.py``, if pydot is still not being maintained. See #5723
 * Remove the ``forest_str`` function from ``readwrite/text.py``. Replace
   existing usages with ``write_network_text``.
 
diff --git a/networkx/conftest.py b/networkx/conftest.py
index 9a25495d580..8b1eeb5f97b 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -89,9 +89,6 @@ def pytest_collection_modifyitems(config, items):
 # TODO: The warnings below need to be dealt with, but for now we silence them.
 @pytest.fixture(autouse=True)
 def set_warnings():
-    warnings.filterwarnings(
-        "ignore", category=DeprecationWarning, message="nx.nx_pydot"
-    )
     warnings.filterwarnings(
         "ignore",
         category=FutureWarning,
diff --git a/networkx/drawing/nx_pydot.py b/networkx/drawing/nx_pydot.py
index 1cd17818373..4e6a4dccf52 100644
--- a/networkx/drawing/nx_pydot.py
+++ b/networkx/drawing/nx_pydot.py
@@ -19,7 +19,6 @@
  - Graphviz:      https://www.graphviz.org
  - DOT Language:  http://www.graphviz.org/doc/info/lang.html
 """
-import warnings
 from locale import getpreferredencoding
 
 import networkx as nx
@@ -41,13 +40,6 @@ def write_dot(G, path):
 
     Path can be a string or a file handle.
     """
-    msg = (
-        "nx.nx_pydot.write_dot depends on the pydot package, which has "
-        "known issues and is not actively maintained. Consider using "
-        "nx.nx_agraph.write_dot instead.\n\n"
-        "See https://github.com/networkx/networkx/issues/5723"
-    )
-    warnings.warn(msg, DeprecationWarning, stacklevel=2)
     P = to_pydot(G)
     path.write(P.to_string())
     return
@@ -79,14 +71,6 @@ def read_dot(path):
     """
     import pydot
 
-    msg = (
-        "nx.nx_pydot.read_dot depends on the pydot package, which has "
-        "known issues and is not actively maintained. Consider using "
-        "nx.nx_agraph.read_dot instead.\n\n"
-        "See https://github.com/networkx/networkx/issues/5723"
-    )
-    warnings.warn(msg, DeprecationWarning, stacklevel=2)
-
     data = path.read()
 
     # List of one or more "pydot.Dot" instances deserialized from this file.
@@ -120,12 +104,6 @@ def from_pydot(P):
     >>> G = nx.Graph(nx.nx_pydot.from_pydot(A))
 
     """
-    msg = (
-        "nx.nx_pydot.from_pydot depends on the pydot package, which has "
-        "known issues and is not actively maintained.\n\n"
-        "See https://github.com/networkx/networkx/issues/5723"
-    )
-    warnings.warn(msg, DeprecationWarning, stacklevel=2)
 
     if P.get_strict(None):  # pydot bug: get_strict() shouldn't take argument
         multiedges = False
@@ -220,13 +198,6 @@ def to_pydot(N):
     """
     import pydot
 
-    msg = (
-        "nx.nx_pydot.to_pydot depends on the pydot package, which has "
-        "known issues and is not actively maintained.\n\n"
-        "See https://github.com/networkx/networkx/issues/5723"
-    )
-    warnings.warn(msg, DeprecationWarning, stacklevel=2)
-
     # set Graphviz graph type
     if N.is_directed():
         graph_type = "digraph"
@@ -348,14 +319,6 @@ def graphviz_layout(G, prog="neato", root=None):
     -----
     This is a wrapper for pydot_layout.
     """
-    msg = (
-        "nx.nx_pydot.graphviz_layout depends on the pydot package, which has "
-        "known issues and is not actively maintained. Consider using "
-        "nx.nx_agraph.graphviz_layout instead.\n\n"
-        "See https://github.com/networkx/networkx/issues/5723"
-    )
-    warnings.warn(msg, DeprecationWarning, stacklevel=2)
-
     return pydot_layout(G=G, prog=prog, root=root)
 
 
@@ -399,12 +362,6 @@ def pydot_layout(G, prog="neato", root=None):
     """
     import pydot
 
-    msg = (
-        "nx.nx_pydot.pydot_layout depends on the pydot package, which has "
-        "known issues and is not actively maintained.\n\n"
-        "See https://github.com/networkx/networkx/issues/5723"
-    )
-    warnings.warn(msg, DeprecationWarning, stacklevel=2)
     P = to_pydot(G)
     if root is not None:
         P.set("root", str(root))
diff --git a/networkx/drawing/tests/test_pydot.py b/networkx/drawing/tests/test_pydot.py
index a58aa1647c9..7085bbecea3 100644
--- a/networkx/drawing/tests/test_pydot.py
+++ b/networkx/drawing/tests/test_pydot.py
@@ -11,7 +11,6 @@
 pydot = pytest.importorskip("pydot")
 
 
-@pytest.mark.xfail
 class TestPydot:
     def pydot_checks(self, G, prog):
         """
diff --git a/pyproject.toml b/pyproject.toml
index 02d9167204e..ee181b83e69 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -78,7 +78,7 @@ doc = [
 extra = [
     'lxml>=4.6',
     'pygraphviz>=1.11',
-    'pydot>=1.4.2',
+    'pydot>=2.0',
     'sympy>=1.10',
 ]
 test = [
diff --git a/requirements/extra.txt b/requirements/extra.txt
index b730004c452..07dc3499f76 100644
--- a/requirements/extra.txt
+++ b/requirements/extra.txt
@@ -2,5 +2,5 @@
 # Do not edit this file; modify pyproject.toml instead.
 lxml>=4.6
 pygraphviz>=1.11
-pydot>=1.4.2
+pydot>=2.0
 sympy>=1.10

From f5730046cc1671c3003f7836dc4e24f175e53418 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Sat, 6 Jan 2024 10:33:46 -0800
Subject: [PATCH 029/129] Future-proofing and improve tests (#7209)

* Fix intermittent doctest failures for expanders with seeding.

* Rm deprecated asftype.

* Fix warnings filter for join.

* Prepare for pandas copy-on-write.
---
 networkx/algorithms/centrality/group.py | 6 +++---
 networkx/conftest.py                    | 4 +++-
 networkx/generators/expanders.py        | 6 +++---
 3 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/networkx/algorithms/centrality/group.py b/networkx/algorithms/centrality/group.py
index 8207a71a5ae..ff17d8f32ed 100644
--- a/networkx/algorithms/centrality/group.py
+++ b/networkx/algorithms/centrality/group.py
@@ -498,15 +498,15 @@ def _heuristic(k, root, DF_tree, D, nodes, greedy):
                         / root_node["sigma"][added_node][y]
                     )
             DF_tree.nodes[node_p]["sigma"][x][y] = root_node["sigma"][x][y] * (1 - dxvy)
-            DF_tree.nodes[node_p]["betweenness"][x][y] = (
+            DF_tree.nodes[node_p]["betweenness"].loc[y, x] = (
                 root_node["betweenness"][x][y] - root_node["betweenness"][x][y] * dxvy
             )
             if y != added_node:
-                DF_tree.nodes[node_p]["betweenness"][x][y] -= (
+                DF_tree.nodes[node_p]["betweenness"].loc[y, x] -= (
                     root_node["betweenness"][x][added_node] * dxyv
                 )
             if x != added_node:
-                DF_tree.nodes[node_p]["betweenness"][x][y] -= (
+                DF_tree.nodes[node_p]["betweenness"].loc[y, x] -= (
                     root_node["betweenness"][added_node][y] * dvxy
                 )
 
diff --git a/networkx/conftest.py b/networkx/conftest.py
index 8b1eeb5f97b..86cea45f944 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -117,7 +117,9 @@ def set_warnings():
         "ignore", category=DeprecationWarning, message="\n\nThe `normalized`"
     )
     warnings.filterwarnings(
-        "ignore", category=DeprecationWarning, message="function `join` is deprecated"
+        "ignore",
+        category=DeprecationWarning,
+        message="The function `join` is deprecated",
     )
     warnings.filterwarnings(
         "ignore",
diff --git a/networkx/generators/expanders.py b/networkx/generators/expanders.py
index 2385682be58..2cd7976025a 100644
--- a/networkx/generators/expanders.py
+++ b/networkx/generators/expanders.py
@@ -248,7 +248,7 @@ def maybe_regular_expander(n, d, *, create_using=None, max_tries=100, seed=None)
 
     Examples
     --------
-    >>> G = nx.maybe_regular_expander(n=200, d=6)
+    >>> G = nx.maybe_regular_expander(n=200, d=6, seed=8020)
 
     Returns
     -------
@@ -387,8 +387,8 @@ def is_regular_expander(G, *, epsilon=0):
 
     _, d = nx.utils.arbitrary_element(G.degree)
 
-    A = nx.adjacency_matrix(G)
-    lams = eigsh(A.asfptype(), which="LM", k=2, return_eigenvectors=False)
+    A = nx.adjacency_matrix(G, dtype=float)
+    lams = eigsh(A, which="LM", k=2, return_eigenvectors=False)
 
     # lambda2 is the second biggest eigenvalue
     lambda2 = min(lams)

From f52696e58ad85161adda1c66870d3a7789f138de Mon Sep 17 00:00:00 2001
From: Jarrod Millman <jarrod.millman@gmail.com>
Date: Mon, 8 Jan 2024 21:37:38 -0800
Subject: [PATCH 030/129] Drop old dependencies per SPEC 0 (#7217)

---
 pyproject.toml           | 4 ++--
 requirements/default.txt | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index ee181b83e69..c25e6217d91 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -55,9 +55,9 @@ nx-loopback = 'networkx.classes.tests.dispatch_interface:dispatcher'
 
 [project.optional-dependencies]
 default = [
-    'numpy>=1.22',
+    'numpy>=1.23',
     'scipy>=1.9,!=1.11.0,!=1.11.1',
-    'matplotlib>=3.5',
+    'matplotlib>=3.6',
     'pandas>=1.4',
 ]
 developer = [
diff --git a/requirements/default.txt b/requirements/default.txt
index 4a0afcd77da..97e1e259dd0 100644
--- a/requirements/default.txt
+++ b/requirements/default.txt
@@ -1,6 +1,6 @@
 # Generated via tools/generate_requirements.py and pre-commit hook.
 # Do not edit this file; modify pyproject.toml instead.
-numpy>=1.22
+numpy>=1.23
 scipy>=1.9,!=1.11.0,!=1.11.1
-matplotlib>=3.5
+matplotlib>=3.6
 pandas>=1.4

From 5c9e8c3585bea6b302aced95d71f614a34310b47 Mon Sep 17 00:00:00 2001
From: Jarrod Millman <jarrod.millman@gmail.com>
Date: Mon, 8 Jan 2024 21:37:49 -0800
Subject: [PATCH 031/129] Update pygraphviz (#7216)

---
 pyproject.toml         | 2 +-
 requirements/extra.txt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index c25e6217d91..078f4ae10bc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -77,7 +77,7 @@ doc = [
 ]
 extra = [
     'lxml>=4.6',
-    'pygraphviz>=1.11',
+    'pygraphviz>=1.12',
     'pydot>=2.0',
     'sympy>=1.10',
 ]
diff --git a/requirements/extra.txt b/requirements/extra.txt
index 07dc3499f76..ad08057f4a1 100644
--- a/requirements/extra.txt
+++ b/requirements/extra.txt
@@ -1,6 +1,6 @@
 # Generated via tools/generate_requirements.py and pre-commit hook.
 # Do not edit this file; modify pyproject.toml instead.
 lxml>=4.6
-pygraphviz>=1.11
+pygraphviz>=1.12
 pydot>=2.0
 sympy>=1.10

From e36da1da83564c788670885baedc1cee99b574ed Mon Sep 17 00:00:00 2001
From: smokestacklightnin
 <125844868+smokestacklightnin@users.noreply.github.com>
Date: Tue, 9 Jan 2024 14:44:24 -0300
Subject: [PATCH 032/129] ENH : Provide non-normalized and normalized directed
 laplacian matrix calculation (#7199)

Adds functionality for directed laplacian matrices

* Remove the `not_implemented_for("directed")` decorator on `laplacian_matrix`

* Add tests for 'laplacian_matrix` as applied to directed graphs

* Add pointers to `directed_laplacian_matrix` and `directed_combinatorial_laplacian_matrix` in docstring of `laplacian_matrix`

* Allow DiGraphs in `normalized_laplacian_matrix`
---
 networkx/linalg/laplacianmatrix.py      | 83 ++++++++++++++++++++--
 networkx/linalg/tests/test_laplacian.py | 94 +++++++++++++++++++++++++
 2 files changed, 173 insertions(+), 4 deletions(-)

diff --git a/networkx/linalg/laplacianmatrix.py b/networkx/linalg/laplacianmatrix.py
index 17bfd6d362b..bd9e1d3c45f 100644
--- a/networkx/linalg/laplacianmatrix.py
+++ b/networkx/linalg/laplacianmatrix.py
@@ -1,4 +1,11 @@
 """Laplacian matrix of graphs.
+
+All calculations here are done using the out-degree. For Laplacians 
+using in-degree, us `G.reverse(copy=False)` instead of `G`.
+
+The `laplacian_matrix` function provides an unnormalized matrix, 
+while `normalized_laplacian_matrix`, `directed_laplacian_matrix`, 
+and `directed_combinatorial_laplacian_matrix` are all normalized.
 """
 import networkx as nx
 from networkx.utils import not_implemented_for
@@ -12,7 +19,6 @@
 ]
 
 
-@not_implemented_for("directed")
 @nx._dispatch(edge_attrs="weight")
 def laplacian_matrix(G, nodelist=None, weight="weight"):
     """Returns the Laplacian matrix of G.
@@ -42,10 +48,19 @@ def laplacian_matrix(G, nodelist=None, weight="weight"):
     -----
     For MultiGraph, the edges weights are summed.
 
+    This returns an unnormalized matrix. For a normalized output,
+    use `normalized_laplacian_matrix`, `directed_laplacian_matrix`,
+    or `directed_combinatorial_laplacian_matrix`.
+
+    This calculation uses the out-degree of the graph `G`. To use the
+    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+
     See Also
     --------
     :func:`~networkx.convert_matrix.to_numpy_array`
     normalized_laplacian_matrix
+    directed_laplacian_matrix
+    directed_combinatorial_laplacian_matrix
     :func:`~networkx.linalg.spectrum.laplacian_spectrum`
 
     Examples
@@ -62,6 +77,25 @@ def laplacian_matrix(G, nodelist=None, weight="weight"):
      [ 0  0  0  1 -1]
      [ 0  0  0 -1  1]]
 
+    >>> edges = [(1, 2), (2, 1), (2, 4), (4, 3), (3, 4),]
+    >>> DiG = nx.DiGraph(edges)
+    >>> print(nx.laplacian_matrix(DiG).toarray())
+    [[ 1 -1  0  0]
+     [-1  2 -1  0]
+     [ 0  0  1 -1]
+     [ 0  0 -1  1]]
+    >>> G = nx.Graph(DiG)
+    >>> print(nx.laplacian_matrix(G).toarray())
+    [[ 1 -1  0  0]
+     [-1  2 -1  0]
+     [ 0 -1  2 -1]
+     [ 0  0 -1  1]]
+
+    References
+    ----------
+    .. [1] Langville, Amy N., and Carl D. Meyer. Google’s PageRank and Beyond:
+       The Science of Search Engine Rankings. Princeton University Press, 2006.
+
     """
     import scipy as sp
 
@@ -74,7 +108,6 @@ def laplacian_matrix(G, nodelist=None, weight="weight"):
     return D - A
 
 
-@not_implemented_for("directed")
 @nx._dispatch(edge_attrs="weight")
 def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     r"""Returns the normalized Laplacian matrix of G.
@@ -114,10 +147,36 @@ def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     If the Graph contains selfloops, D is defined as ``diag(sum(A, 1))``, where A is
     the adjacency matrix [2]_.
 
+    This calculation uses the out-degree of the graph `G`. To use the
+    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+
+    For an unnormalized output, use `laplacian_matrix`.
+
+    Examples
+    --------
+
+    >>> import numpy as np
+    >>> np.set_printoptions(precision=4) # To print with lower precision
+    >>> edges = [(1, 2), (2, 1), (2, 4), (4, 3), (3, 4),]
+    >>> DiG = nx.DiGraph(edges)
+    >>> print(nx.normalized_laplacian_matrix(DiG).toarray())
+    [[ 1.     -0.7071  0.      0.    ]
+     [-0.7071  1.     -0.7071  0.    ]
+     [ 0.      0.      1.     -1.    ]
+     [ 0.      0.     -1.      1.    ]]
+    >>> G = nx.Graph(DiG)
+    >>> print(nx.normalized_laplacian_matrix(G).toarray())
+    [[ 1.     -0.7071  0.      0.    ]
+     [-0.7071  1.     -0.5     0.    ]
+     [ 0.     -0.5     1.     -0.7071]
+     [ 0.      0.     -0.7071  1.    ]]
+
     See Also
     --------
     laplacian_matrix
     normalized_laplacian_spectrum
+    directed_laplacian_matrix
+    directed_combinatorial_laplacian_matrix
 
     References
     ----------
@@ -126,6 +185,8 @@ def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     .. [2] Steve Butler, Interlacing For Weighted Graphs Using The Normalized
        Laplacian, Electronic Journal of Linear Algebra, Volume 16, pp. 90-98,
        March 2007.
+    .. [3] Langville, Amy N., and Carl D. Meyer. Google’s PageRank and Beyond:
+       The Science of Search Engine Rankings. Princeton University Press, 2006.
     """
     import numpy as np
     import scipy as sp
@@ -195,7 +256,7 @@ def directed_laplacian_matrix(
 
     .. math::
 
-        L = I - (\Phi^{1/2} P \Phi^{-1/2} + \Phi^{-1/2} P^T \Phi^{1/2} ) / 2
+        L = I - \frac{1}{2} \left (\Phi^{1/2} P \Phi^{-1/2} + \Phi^{-1/2} P^T \Phi^{1/2} \right )
 
     where `I` is the identity matrix, `P` is the transition matrix of the
     graph, and `\Phi` a matrix with the Perron vector of `P` in the diagonal and
@@ -237,9 +298,16 @@ def directed_laplacian_matrix(
     -----
     Only implemented for DiGraphs
 
+    The result is always a symmetric matrix.
+
+    This calculation uses the out-degree of the graph `G`. To use the
+    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+
     See Also
     --------
     laplacian_matrix
+    normalized_laplacian_matrix
+    directed_combinatorial_laplacian_matrix
 
     References
     ----------
@@ -287,7 +355,7 @@ def directed_combinatorial_laplacian_matrix(
 
     .. math::
 
-        L = \Phi - (\Phi P + P^T \Phi) / 2
+        L = \Phi - \frac{1}{2} \left (\Phi P + P^T \Phi \right)
 
     where `P` is the transition matrix of the graph and `\Phi` a matrix
     with the Perron vector of `P` in the diagonal and zeros elsewhere [1]_.
@@ -328,9 +396,16 @@ def directed_combinatorial_laplacian_matrix(
     -----
     Only implemented for DiGraphs
 
+    The result is always a symmetric matrix.
+
+    This calculation uses the out-degree of the graph `G`. To use the
+    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+
     See Also
     --------
     laplacian_matrix
+    normalized_laplacian_matrix
+    directed_laplacian_matrix
 
     References
     ----------
diff --git a/networkx/linalg/tests/test_laplacian.py b/networkx/linalg/tests/test_laplacian.py
index 78cddacd3bd..23f1b28e19f 100644
--- a/networkx/linalg/tests/test_laplacian.py
+++ b/networkx/linalg/tests/test_laplacian.py
@@ -24,6 +24,31 @@ def setup_class(cls):
         for node in cls.Gsl.nodes():
             cls.Gsl.add_edge(node, node)
 
+        # Graph used as an example in Sec. 4.1 of Langville and Meyer,
+        # "Google's PageRank and Beyond".
+        cls.DiG = nx.DiGraph()
+        cls.DiG.add_edges_from(
+            (
+                (1, 2),
+                (1, 3),
+                (3, 1),
+                (3, 2),
+                (3, 5),
+                (4, 5),
+                (4, 6),
+                (5, 4),
+                (5, 6),
+                (6, 4),
+            )
+        )
+        cls.DiMG = nx.MultiDiGraph(cls.DiG)
+        cls.DiWG = nx.DiGraph(
+            (u, v, {"weight": 0.5, "other": 0.3}) for (u, v) in cls.DiG.edges()
+        )
+        cls.DiGsl = cls.DiG.copy()
+        for node in cls.DiGsl.nodes():
+            cls.DiGsl.add_edge(node, node)
+
     def test_laplacian(self):
         "Graph Laplacian"
         # fmt: off
@@ -35,6 +60,16 @@ def test_laplacian(self):
         # fmt: on
         WL = 0.5 * NL
         OL = 0.3 * NL
+        # fmt: off
+        DiNL = np.array([[ 2, -1, -1,  0,  0,  0],
+                         [ 0,  0,  0,  0,  0,  0],
+                         [-1, -1,  3, -1,  0,  0],
+                         [ 0,  0,  0,  2, -1, -1],
+                         [ 0,  0,  0, -1,  2, -1],
+                         [ 0,  0,  0,  0, -1,  1]])
+        # fmt: on
+        DiWL = 0.5 * DiNL
+        DiOL = 0.3 * DiNL
         np.testing.assert_equal(nx.laplacian_matrix(self.G).todense(), NL)
         np.testing.assert_equal(nx.laplacian_matrix(self.MG).todense(), NL)
         np.testing.assert_equal(
@@ -47,6 +82,20 @@ def test_laplacian(self):
             nx.laplacian_matrix(self.WG, weight="other").todense(), OL
         )
 
+        np.testing.assert_equal(nx.laplacian_matrix(self.DiG).todense(), DiNL)
+        np.testing.assert_equal(nx.laplacian_matrix(self.DiMG).todense(), DiNL)
+        np.testing.assert_equal(
+            nx.laplacian_matrix(self.DiG, nodelist=[1, 2]).todense(),
+            np.array([[1, -1], [0, 0]]),
+        )
+        np.testing.assert_equal(nx.laplacian_matrix(self.DiWG).todense(), DiWL)
+        np.testing.assert_equal(
+            nx.laplacian_matrix(self.DiWG, weight=None).todense(), DiNL
+        )
+        np.testing.assert_equal(
+            nx.laplacian_matrix(self.DiWG, weight="other").todense(), DiOL
+        )
+
     def test_normalized_laplacian(self):
         "Generalized Graph Laplacian"
         # fmt: off
@@ -65,6 +114,25 @@ def test_normalized_laplacian(self):
                         [-0.2887, -0.3333,  0.6667,  0.    ,  0.    ],
                         [-0.3536,  0.    ,  0.    ,  0.5   ,  0.    ],
                         [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ]])
+
+        DiG = np.array([[ 1.    ,  0.    , -0.4082,  0.    ,  0.    ,  0.    ],
+                        [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ,  0.    ],
+                        [-0.4082,  0.    ,  1.    ,  0.    , -0.4082,  0.    ],
+                        [ 0.    ,  0.    ,  0.    ,  1.    , -0.5   , -0.7071],
+                        [ 0.    ,  0.    ,  0.    , -0.5   ,  1.    , -0.7071],
+                        [ 0.    ,  0.    ,  0.    , -0.7071,  0.     , 1.    ]])
+        DiGL = np.array([[ 1.    ,  0.    , -0.4082,  0.    ,  0.    ,  0.    ],
+                         [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ,  0.    ],
+                         [-0.4082,  0.    ,  1.    , -0.4082,  0.    ,  0.    ],
+                         [ 0.    ,  0.    ,  0.    ,  1.    , -0.5   , -0.7071],
+                         [ 0.    ,  0.    ,  0.    , -0.5   ,  1.    , -0.7071],
+                         [ 0.    ,  0.    ,  0.    ,  0.    , -0.7071,  1.    ]])
+        DiLsl = np.array([[ 0.6667, -0.5774, -0.2887,  0.    ,  0.    ,  0.    ],
+                          [ 0.    ,  0.    ,  0.    ,  0.    ,  0.    ,  0.    ],
+                          [-0.2887, -0.5   ,  0.75  , -0.2887,  0.    ,  0.    ],
+                          [ 0.    ,  0.    ,  0.    ,  0.6667, -0.3333, -0.4082],
+                          [ 0.    ,  0.    ,  0.    , -0.3333,  0.6667, -0.4082],
+                          [ 0.    ,  0.    ,  0.    ,  0.    , -0.4082,  0.5   ]])
         # fmt: on
 
         np.testing.assert_almost_equal(
@@ -90,6 +158,32 @@ def test_normalized_laplacian(self):
             nx.normalized_laplacian_matrix(self.Gsl).todense(), Lsl, decimal=3
         )
 
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(
+                self.DiG,
+                nodelist=range(1, 1 + 6),
+            ).todense(),
+            DiG,
+            decimal=3,
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.DiG).todense(), DiGL, decimal=3
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.DiMG).todense(), DiGL, decimal=3
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.DiWG).todense(), DiGL, decimal=3
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.DiWG, weight="other").todense(),
+            DiGL,
+            decimal=3,
+        )
+        np.testing.assert_almost_equal(
+            nx.normalized_laplacian_matrix(self.DiGsl).todense(), DiLsl, decimal=3
+        )
+
 
 def test_directed_laplacian():
     "Directed Laplacian"

From 205cd05ab07293ebbab8b7329adb00beb862fef0 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Tue, 9 Jan 2024 19:57:56 -0800
Subject: [PATCH 033/129] Refactor geometric_soft_configuration_model tests for
 performance (#7210)

* TST: Consolidate mean kappa/deg test and use smaller graph.

* TST: Reduce size of test graphs.
---
 networkx/generators/tests/test_geometric.py | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/networkx/generators/tests/test_geometric.py b/networkx/generators/tests/test_geometric.py
index 604a388f93f..f1c68bead51 100644
--- a/networkx/generators/tests/test_geometric.py
+++ b/networkx/generators/tests/test_geometric.py
@@ -387,19 +387,15 @@ def test_set_attributes_S1():
     assert len(radii) == 100
 
 
-def test_mean_kappas_S1():
+def test_mean_kappas_mean_degree_S1():
     G = nx.geometric_soft_configuration_graph(
-        beta=2.5, n=5000, gamma=2.7, mean_degree=10, seed=42
+        beta=2.5, n=50, gamma=2.7, mean_degree=10, seed=8023
     )
+
     kappas = nx.get_node_attributes(G, "kappa")
     mean_kappas = sum(kappas.values()) / len(kappas)
     assert math.fabs(mean_kappas - 10) < 0.5
 
-
-def test_mean_degree_S1():
-    G = nx.geometric_soft_configuration_graph(
-        beta=2.5, n=5000, gamma=2.7, mean_degree=10, seed=42
-    )
     degrees = dict(G.degree())
     mean_degree = sum(degrees.values()) / len(degrees)
     assert math.fabs(mean_degree - 10) < 1
@@ -480,10 +476,10 @@ def test_mean_degree_influence_on_connectivity_S1():
 
 def test_compare_mean_kappas_different_gammas_S1():
     G1 = nx.geometric_soft_configuration_graph(
-        beta=1.5, n=2000, gamma=2.7, mean_degree=20, seed=42
+        beta=1.5, n=20, gamma=2.7, mean_degree=5, seed=42
     )
     G2 = nx.geometric_soft_configuration_graph(
-        beta=1.5, n=2000, gamma=3.5, mean_degree=20, seed=42
+        beta=1.5, n=20, gamma=3.5, mean_degree=5, seed=42
     )
     kappas1 = nx.get_node_attributes(G1, "kappa")
     mean_kappas1 = sum(kappas1.values()) / len(kappas1)

From 0204a246a8bfba38153f03b3967a669c05a7181f Mon Sep 17 00:00:00 2001
From: Mauricio Souza de Alencar <856825+mdealencar@users.noreply.github.com>
Date: Wed, 10 Jan 2024 18:30:19 +0100
Subject: [PATCH 034/129] Add `add_half_edge` method to PlanarEmbedding (#7202)

Add a new method for adding edges to PlanarEmbedding as an
alternative to the existing three methods add..._cw, add..._ccw, and add..._first_edge.

This tightens the API and allows for dropping explicit tracking of the `first_nbr`
internal state variable.

* feat: drop the use of node attribute "first_nbr" in PlanarEmbedding (planarity.py)

* feat: add method PlanarEmbedding.add_half_edge(), which superceeds the _cw and _ccw varieties, plus update the planar_drawing and tests accordingly (planar_drawing.py, planarity.py, test_planarity.py)

---------

Co-authored-by: mdealencar <mdealencar@users.noreply.github.com>
Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@caltech.edu>
---
 networkx/algorithms/planar_drawing.py       |   8 +-
 networkx/algorithms/planarity.py            | 206 ++++++++++++--------
 networkx/algorithms/tests/test_planarity.py |  88 ++++++---
 3 files changed, 193 insertions(+), 109 deletions(-)

diff --git a/networkx/algorithms/planar_drawing.py b/networkx/algorithms/planar_drawing.py
index 5c091e26e4d..ea25809b6ae 100644
--- a/networkx/algorithms/planar_drawing.py
+++ b/networkx/algorithms/planar_drawing.py
@@ -326,8 +326,8 @@ def triangulate_face(embedding, v1, v2):
             v1, v2, v3 = v2, v3, v4
         else:
             # Add edge for triangulation
-            embedding.add_half_edge_cw(v1, v3, v2)
-            embedding.add_half_edge_ccw(v3, v1, v2)
+            embedding.add_half_edge(v1, v3, ccw=v2)
+            embedding.add_half_edge(v3, v1, cw=v2)
             v1, v2, v3 = v1, v3, v4
         # Get next node
         _, v4 = embedding.next_face_half_edge(v2, v3)
@@ -445,8 +445,8 @@ def make_bi_connected(embedding, starting_node, outgoing_node, edges_counted):
         # cycle is not completed yet
         if v2 in face_set:
             # v2 encountered twice: Add edge to ensure 2-connectedness
-            embedding.add_half_edge_cw(v1, v3, v2)
-            embedding.add_half_edge_ccw(v3, v1, v2)
+            embedding.add_half_edge(v1, v3, ccw=v2)
+            embedding.add_half_edge(v3, v1, cw=v2)
             edges_counted.add((v2, v3))
             edges_counted.add((v3, v1))
             v2 = v1
diff --git a/networkx/algorithms/planarity.py b/networkx/algorithms/planarity.py
index ad46f4739e5..c5611eca39f 100644
--- a/networkx/algorithms/planarity.py
+++ b/networkx/algorithms/planarity.py
@@ -376,7 +376,7 @@ def lr_planarity(self):
             # initialize the embedding
             previous_node = None
             for w in self.ordered_adjs[v]:
-                self.embedding.add_half_edge_cw(v, w, previous_node)
+                self.embedding.add_half_edge(v, w, ccw=previous_node)
                 previous_node = w
 
         # Free no longer used variables
@@ -436,7 +436,7 @@ def lr_planarity_recursive(self):
             # initialize the embedding
             previous_node = None
             for w in self.ordered_adjs[v]:
-                self.embedding.add_half_edge_cw(v, w, previous_node)
+                self.embedding.add_half_edge(v, w, ccw=previous_node)
                 previous_node = w
 
         # compute the complete embedding
@@ -714,9 +714,9 @@ def dfs_embedding(self, v):
                     break  # handle next node in dfs_stack (i.e. w)
                 else:  # back edge
                     if self.side[ei] == 1:
-                        self.embedding.add_half_edge_cw(w, v, self.right_ref[w])
+                        self.embedding.add_half_edge(w, v, ccw=self.right_ref[w])
                     else:
-                        self.embedding.add_half_edge_ccw(w, v, self.left_ref[w])
+                        self.embedding.add_half_edge(w, v, cw=self.left_ref[w])
                         self.left_ref[w] = v
 
     def dfs_embedding_recursive(self, v):
@@ -731,10 +731,10 @@ def dfs_embedding_recursive(self, v):
             else:  # back edge
                 if self.side[ei] == 1:
                     # place v directly after right_ref[w] in embed. list of w
-                    self.embedding.add_half_edge_cw(w, v, self.right_ref[w])
+                    self.embedding.add_half_edge(w, v, ccw=self.right_ref[w])
                 else:
                     # place v directly before left_ref[w] in embed. list of w
-                    self.embedding.add_half_edge_ccw(w, v, self.left_ref[w])
+                    self.embedding.add_half_edge(w, v, cw=self.left_ref[w])
                     self.left_ref[w] = v
 
     def sign(self, e):
@@ -791,15 +791,12 @@ class PlanarEmbedding(nx.DiGraph):
     * Edges must go in both directions (because the edge attributes differ)
     * Every edge must have a 'cw' and 'ccw' attribute which corresponds to a
       correct planar embedding.
-    * A node with non zero degree must have a node attribute 'first_nbr'.
 
     As long as a PlanarEmbedding is invalid only the following methods should
     be called:
 
-    * :meth:`add_half_edge_ccw`
-    * :meth:`add_half_edge_cw`
+    * :meth:`add_half_edge`
     * :meth:`connect_components`
-    * :meth:`add_half_edge_first`
 
     Even though the graph is a subclass of nx.DiGraph, it can still be used
     for algorithms that require undirected graphs, because the method
@@ -808,14 +805,14 @@ class PlanarEmbedding(nx.DiGraph):
 
     **Half edges:**
 
-    In methods like `add_half_edge_ccw` the term "half-edge" is used, which is
+    In methods like `add_half_edge` the term "half-edge" is used, which is
     a term that is used in `doubly connected edge lists
     <https://en.wikipedia.org/wiki/Doubly_connected_edge_list>`_. It is used
     to emphasize that the edge is only in one direction and there exists
     another half-edge in the opposite direction.
     While conventional edges always have two faces (including outer face) next
     to them, it is possible to assign each half-edge *exactly one* face.
-    For a half-edge (u, v) that is orientated such that u is below v then the
+    For a half-edge (u, v) that is oriented such that u is below v then the
     face that belongs to (u, v) is to the right of this half-edge.
 
     See Also
@@ -833,23 +830,23 @@ class PlanarEmbedding(nx.DiGraph):
     Create an embedding of a star graph (compare `nx.star_graph(3)`):
 
     >>> G = nx.PlanarEmbedding()
-    >>> G.add_half_edge_cw(0, 1, None)
-    >>> G.add_half_edge_cw(0, 2, 1)
-    >>> G.add_half_edge_cw(0, 3, 2)
-    >>> G.add_half_edge_cw(1, 0, None)
-    >>> G.add_half_edge_cw(2, 0, None)
-    >>> G.add_half_edge_cw(3, 0, None)
+    >>> G.add_half_edge(0, 1)
+    >>> G.add_half_edge(0, 2, ccw=1)
+    >>> G.add_half_edge(0, 3, ccw=2)
+    >>> G.add_half_edge(1, 0)
+    >>> G.add_half_edge(2, 0)
+    >>> G.add_half_edge(3, 0)
 
     Alternatively the same embedding can also be defined in counterclockwise
     orientation. The following results in exactly the same PlanarEmbedding:
 
     >>> G = nx.PlanarEmbedding()
-    >>> G.add_half_edge_ccw(0, 1, None)
-    >>> G.add_half_edge_ccw(0, 3, 1)
-    >>> G.add_half_edge_ccw(0, 2, 3)
-    >>> G.add_half_edge_ccw(1, 0, None)
-    >>> G.add_half_edge_ccw(2, 0, None)
-    >>> G.add_half_edge_ccw(3, 0, None)
+    >>> G.add_half_edge(0, 1)
+    >>> G.add_half_edge(0, 3, cw=1)
+    >>> G.add_half_edge(0, 2, cw=3)
+    >>> G.add_half_edge(1, 0)
+    >>> G.add_half_edge(2, 0)
+    >>> G.add_half_edge(3, 0)
 
     After creating a graph, it is possible to validate that the PlanarEmbedding
     object is correct:
@@ -894,8 +891,10 @@ def set_data(self, data):
 
         """
         for v in data:
+            ref = None
             for w in reversed(data[v]):
-                self.add_half_edge_first(v, w)
+                self.add_half_edge(v, w, cw=ref)
+                ref = w
 
     def neighbors_cw_order(self, v):
         """Generator for the neighbors of v in clockwise order.
@@ -909,15 +908,89 @@ def neighbors_cw_order(self, v):
         node
 
         """
-        if len(self[v]) == 0:
+        succs = self._succ[v]
+        if not succs:
             # v has no neighbors
             return
-        start_node = self.nodes[v]["first_nbr"]
+        start_node = next(reversed(succs))
         yield start_node
-        current_node = self[v][start_node]["cw"]
+        current_node = succs[start_node]["cw"]
         while start_node != current_node:
             yield current_node
-            current_node = self[v][current_node]["cw"]
+            current_node = succs[current_node]["cw"]
+
+    def add_half_edge(self, start_node, end_node, *, cw=None, ccw=None):
+        """Adds a half-edge from `start_node` to `end_node`.
+
+        If the half-edge is not the first one out of `start_node`, a reference
+        node must be provided either in the clockwise (parameter `cw`) or in
+        the counterclockwise (parameter `ccw`) direction. Only one of `cw`/`ccw`
+        can be specified (or neither in the case of the first edge).
+        Note that specifying a reference in the clockwise (`cw`) direction means
+        inserting the new edge in the first counterclockwise position with
+        respect to the reference (and vice-versa).
+
+        Parameters
+        ----------
+        start_node : node
+            Start node of inserted edge.
+        end_node : node
+            End node of inserted edge.
+        cw, ccw: node
+            End node of reference edge.
+            Omit or pass `None` if adding the first out-half-edge of `start_node`.
+
+        Raises
+        ------
+        NetworkXException
+            If the `cw` or `ccw` node is not a successor of `start_node`.
+            If `start_node` has successors, but neither `cw` or `ccw` is provided.
+            If both `cw` and `ccw` are specified.
+
+        See Also
+        --------
+        connect_components
+        """
+
+        succs = self._succ.get(start_node)
+        if succs:
+            # there is already some edge out of start_node
+            leftmost_nbr = next(reversed(self._succ[start_node]))
+            if cw is not None:
+                if cw not in succs:
+                    raise nx.NetworkXError("Invalid clockwise reference node.")
+                if ccw is not None:
+                    raise nx.NetworkXError("Only one of cw/ccw can be specified.")
+                ref_ccw = succs[cw]["ccw"]
+                self.add_edge(start_node, end_node, cw=cw, ccw=ref_ccw)
+                succs[ref_ccw]["cw"] = end_node
+                succs[cw]["ccw"] = end_node
+                # when (cw == leftmost_nbr), the newly added neighbor is
+                # already at the end of dict self._succ[start_node] and
+                # takes the place of the former leftmost_nbr
+                move_leftmost_nbr_to_end = cw != leftmost_nbr
+            elif ccw is not None:
+                if ccw not in succs:
+                    raise nx.NetworkXError("Invalid counterclockwise reference node.")
+                ref_cw = succs[ccw]["cw"]
+                self.add_edge(start_node, end_node, cw=ref_cw, ccw=ccw)
+                succs[ref_cw]["ccw"] = end_node
+                succs[ccw]["cw"] = end_node
+                move_leftmost_nbr_to_end = True
+            else:
+                raise nx.NetworkXError(
+                    "Node already has out-half-edge(s), either cw or ccw reference node required."
+                )
+            if move_leftmost_nbr_to_end:
+                # LRPlanarity (via self.add_half_edge_first()) requires that
+                # we keep track of the leftmost neighbor, which we accomplish
+                # by keeping it as the last key in dict self._succ[start_node]
+                succs[leftmost_nbr] = succs.pop(leftmost_nbr)
+        else:
+            if cw is not None or ccw is not None:
+                raise nx.NetworkXError("Invalid reference node.")
+            # adding the first edge out of start_node
+            self.add_edge(start_node, end_node, ccw=end_node, cw=end_node)
 
     def check_structure(self):
         """Runs without exceptions if this object is valid.
@@ -927,7 +1000,6 @@ def check_structure(self):
         * Edges go in both directions (because the edge attributes differ).
         * Every edge has a 'cw' and 'ccw' attribute which corresponds to a
           correct planar embedding.
-        * A node with a degree larger than 0 has a node attribute 'first_nbr'.
 
         Running this method verifies that the underlying Graph must be planar.
 
@@ -1000,24 +1072,12 @@ def add_half_edge_ccw(self, start_node, end_node, reference_neighbor):
 
         See Also
         --------
+        add_half_edge
         add_half_edge_cw
         connect_components
-        add_half_edge_first
 
         """
-        if reference_neighbor is None:
-            # The start node has no neighbors
-            self.add_edge(start_node, end_node)  # Add edge to graph
-            self[start_node][end_node]["cw"] = end_node
-            self[start_node][end_node]["ccw"] = end_node
-            self.nodes[start_node]["first_nbr"] = end_node
-        else:
-            ccw_reference = self[start_node][reference_neighbor]["ccw"]
-            self.add_half_edge_cw(start_node, end_node, ccw_reference)
-
-            if reference_neighbor == self.nodes[start_node].get("first_nbr", None):
-                # Update first neighbor
-                self.nodes[start_node]["first_nbr"] = end_node
+        self.add_half_edge(start_node, end_node, cw=reference_neighbor)
 
     def add_half_edge_cw(self, start_node, end_node, reference_neighbor):
         """Adds a half-edge from start_node to end_node.
@@ -1041,31 +1101,11 @@ def add_half_edge_cw(self, start_node, end_node, reference_neighbor):
 
         See Also
         --------
+        add_half_edge
         add_half_edge_ccw
         connect_components
-        add_half_edge_first
         """
-        self.add_edge(start_node, end_node)  # Add edge to graph
-
-        if reference_neighbor is None:
-            # The start node has no neighbors
-            self[start_node][end_node]["cw"] = end_node
-            self[start_node][end_node]["ccw"] = end_node
-            self.nodes[start_node]["first_nbr"] = end_node
-            return
-
-        if reference_neighbor not in self[start_node]:
-            raise nx.NetworkXException(
-                "Cannot add edge. Reference neighbor does not exist"
-            )
-
-        # Get half-edge at the other side
-        cw_reference = self[start_node][reference_neighbor]["cw"]
-        # Alter half-edge data structures
-        self[start_node][reference_neighbor]["cw"] = end_node
-        self[start_node][end_node]["cw"] = cw_reference
-        self[start_node][cw_reference]["ccw"] = end_node
-        self[start_node][end_node]["ccw"] = reference_neighbor
+        self.add_half_edge(start_node, end_node, ccw=reference_neighbor)
 
     def connect_components(self, v, w):
         """Adds half-edges for (v, w) and (w, v) at some position.
@@ -1084,15 +1124,24 @@ def connect_components(self, v, w):
 
         See Also
         --------
-        add_half_edge_ccw
-        add_half_edge_cw
-        add_half_edge_first
+        add_half_edge
         """
-        self.add_half_edge_first(v, w)
-        self.add_half_edge_first(w, v)
+        if v in self._succ and self._succ[v]:
+            ref = next(reversed(self._succ[v]))
+        else:
+            ref = None
+        self.add_half_edge(v, w, cw=ref)
+        if w in self._succ and self._succ[w]:
+            ref = next(reversed(self._succ[w]))
+        else:
+            ref = None
+        self.add_half_edge(w, v, cw=ref)
 
     def add_half_edge_first(self, start_node, end_node):
-        """The added half-edge is inserted at the first position in the order.
+        """Add a half-edge and set end_node as start_node's leftmost neighbor.
+
+        The new edge is inserted counterclockwise with respect to the current
+        leftmost neighbor, if there is one.
 
         Parameters
         ----------
@@ -1101,15 +1150,14 @@ def add_half_edge_first(self, start_node, end_node):
 
         See Also
         --------
-        add_half_edge_ccw
-        add_half_edge_cw
+        add_half_edge
         connect_components
         """
-        if start_node in self and "first_nbr" in self.nodes[start_node]:
-            reference = self.nodes[start_node]["first_nbr"]
-        else:
-            reference = None
-        self.add_half_edge_ccw(start_node, end_node, reference)
+        succs = self._succ.get(start_node)
+        # the leftmost neighbor is the last entry in the
+        # self._succ[start_node] dict
+        leftmost_nbr = next(reversed(succs)) if succs else None
+        self.add_half_edge(start_node, end_node, cw=leftmost_nbr)
 
     def next_face_half_edge(self, v, w):
         """Returns the following half-edge left of a face.
diff --git a/networkx/algorithms/tests/test_planarity.py b/networkx/algorithms/tests/test_planarity.py
index 470b1d23bb8..02b1d32a922 100644
--- a/networkx/algorithms/tests/test_planarity.py
+++ b/networkx/algorithms/tests/test_planarity.py
@@ -372,48 +372,82 @@ def check_counterexample(G, sub_graph):
 
 
 class TestPlanarEmbeddingClass:
+    def test_add_half_edge(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.add_half_edge(0, 1)
+        with pytest.raises(
+            nx.NetworkXException, match="Invalid clockwise reference node."
+        ):
+            embedding.add_half_edge(0, 2, cw=3)
+        with pytest.raises(
+            nx.NetworkXException, match="Invalid counterclockwise reference node."
+        ):
+            embedding.add_half_edge(0, 2, ccw=3)
+        with pytest.raises(
+            nx.NetworkXException, match="Only one of cw/ccw can be specified."
+        ):
+            embedding.add_half_edge(0, 2, cw=1, ccw=1)
+        with pytest.raises(
+            nx.NetworkXException,
+            match=(
+                r"Node already has out-half-edge\(s\), either"
+                " cw or ccw reference node required."
+            ),
+        ):
+            embedding.add_half_edge(0, 2)
+        # these should work
+        embedding.add_half_edge(0, 2, cw=1)
+        embedding.add_half_edge(0, 3, ccw=1)
+        assert sorted(embedding.edges(data=True)) == [
+            (0, 1, {"ccw": 2, "cw": 3}),
+            (0, 2, {"cw": 1, "ccw": 3}),
+            (0, 3, {"cw": 2, "ccw": 1}),
+        ]
+
     def test_get_data(self):
-        embedding = self.get_star_embedding(3)
+        embedding = self.get_star_embedding(4)
         data = embedding.get_data()
-        data_cmp = {0: [2, 1], 1: [0], 2: [0]}
+        data_cmp = {0: [3, 2, 1], 1: [0], 2: [0], 3: [0]}
         assert data == data_cmp
 
     def test_missing_edge_orientation(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.add_edge(1, 2)
+        embedding.add_edge(2, 1)
         with pytest.raises(nx.NetworkXException):
-            embedding = nx.PlanarEmbedding()
-            embedding.add_edge(1, 2)
-            embedding.add_edge(2, 1)
             # Invalid structure because the orientation of the edge was not set
             embedding.check_structure()
 
     def test_invalid_edge_orientation(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.add_half_edge(1, 2)
+        embedding.add_half_edge(2, 1)
+        embedding.add_edge(1, 3)
         with pytest.raises(nx.NetworkXException):
-            embedding = nx.PlanarEmbedding()
-            embedding.add_half_edge_first(1, 2)
-            embedding.add_half_edge_first(2, 1)
-            embedding.add_edge(1, 3)
             embedding.check_structure()
 
     def test_missing_half_edge(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.add_half_edge(1, 2)
         with pytest.raises(nx.NetworkXException):
-            embedding = nx.PlanarEmbedding()
-            embedding.add_half_edge_first(1, 2)
             # Invalid structure because other half edge is missing
             embedding.check_structure()
 
     def test_not_fulfilling_euler_formula(self):
+        embedding = nx.PlanarEmbedding()
+        for i in range(5):
+            ref = None
+            for j in range(5):
+                if i != j:
+                    embedding.add_half_edge(i, j, cw=ref)
+                    ref = j
         with pytest.raises(nx.NetworkXException):
-            embedding = nx.PlanarEmbedding()
-            for i in range(5):
-                for j in range(5):
-                    if i != j:
-                        embedding.add_half_edge_first(i, j)
             embedding.check_structure()
 
     def test_missing_reference(self):
-        with pytest.raises(nx.NetworkXException):
-            embedding = nx.PlanarEmbedding()
-            embedding.add_half_edge_cw(1, 2, 3)
+        embedding = nx.PlanarEmbedding()
+        with pytest.raises(nx.NetworkXException, match="Invalid reference node."):
+            embedding.add_half_edge(1, 2, ccw=3)
 
     def test_connect_components(self):
         embedding = nx.PlanarEmbedding()
@@ -421,22 +455,24 @@ def test_connect_components(self):
 
     def test_successful_face_traversal(self):
         embedding = nx.PlanarEmbedding()
-        embedding.add_half_edge_first(1, 2)
-        embedding.add_half_edge_first(2, 1)
+        embedding.add_half_edge(1, 2)
+        embedding.add_half_edge(2, 1)
         face = embedding.traverse_face(1, 2)
         assert face == [1, 2]
 
     def test_unsuccessful_face_traversal(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.add_edge(1, 2, ccw=2, cw=3)
+        embedding.add_edge(2, 1, ccw=1, cw=3)
         with pytest.raises(nx.NetworkXException):
-            embedding = nx.PlanarEmbedding()
-            embedding.add_edge(1, 2, ccw=2, cw=3)
-            embedding.add_edge(2, 1, ccw=1, cw=3)
             embedding.traverse_face(1, 2)
 
     @staticmethod
     def get_star_embedding(n):
         embedding = nx.PlanarEmbedding()
+        ref = None
         for i in range(1, n):
-            embedding.add_half_edge_first(0, i)
-            embedding.add_half_edge_first(i, 0)
+            embedding.add_half_edge(0, i, cw=ref)
+            ref = i
+            embedding.add_half_edge(i, 0)
         return embedding

From 7e01590c9d493ea05a9395075e7c4ca5c3917248 Mon Sep 17 00:00:00 2001
From: AKSHAYA MADHURI <76612327+akshayamadhuri@users.noreply.github.com>
Date: Thu, 11 Jan 2024 06:19:32 +0530
Subject: [PATCH 035/129] Improve docs for optimal_edit_paths (#7130)

Provide further detail on how optimal edit paths can be used to
transform G1 to be isomorphic with G2.

Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 networkx/algorithms/similarity.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index 3a1cfff8147..183b41f66b6 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -322,7 +322,8 @@ def optimal_edit_paths(
         edge_edit_path : list of tuples ((u1, v1), (u2, v2))
 
     cost : numeric
-        Optimal edit path cost (graph edit distance).
+        Optimal edit path cost (graph edit distance). When the cost
+        is zero, it indicates that `G1` and `G2` are isomorphic.
 
     Examples
     --------
@@ -334,6 +335,14 @@ def optimal_edit_paths(
     >>> cost
     5.0
 
+    Notes
+    -----
+    To transform `G1` into a graph isomorphic to `G2`, apply the node
+    and edge edits in the returned ``edit_paths``.
+    In the case of isomorphic graphs, the cost is zero, and the paths
+    represent different isomorphic mappings (isomorphisms). That is, the
+    edits involve renaming nodes and edges to match the structure of `G2`.
+
     See Also
     --------
     graph_edit_distance, optimize_edit_paths

From 54eca158c1ec10ea996fb4744b030bd47a42ff73 Mon Sep 17 00:00:00 2001
From: Nihal John George <31016048+nihalgeorge01@users.noreply.github.com>
Date: Thu, 11 Jan 2024 02:25:16 -0500
Subject: [PATCH 036/129] Fix random_spanning_tree() for single node and empty
 graphs (#7211)

---
 networkx/algorithms/tree/mst.py            | 13 ++++++++----
 networkx/algorithms/tree/tests/test_mst.py | 24 ++++++++++++++++++++++
 2 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/networkx/algorithms/tree/mst.py b/networkx/algorithms/tree/mst.py
index f4cec03dc30..ee264d41ae5 100644
--- a/networkx/algorithms/tree/mst.py
+++ b/networkx/algorithms/tree/mst.py
@@ -897,14 +897,15 @@ def spanning_tree_total_weight(G, weight):
             #    itself.
             if G.number_of_edges() == 1:
                 return G.edges(data=weight).__iter__().__next__()[2]
-            # 2. There are more than two edges in the graph. Then, we can find the
+            # 2. There are no edges or two or more edges in the graph. Then, we find the
             #    total weight of the spanning trees using the formula in the
-            #    reference paper: take the weight of that edge and multiple it by
-            #    the number of spanning trees which have to include that edge. This
+            #    reference paper: take the weight of each edge and multiply it by
+            #    the number of spanning trees which include that edge. This
             #    can be accomplished by contracting the edge and finding the
             #    multiplicative total spanning tree weight if the weight of each edge
             #    is assumed to be 1, which is conveniently built into networkx already,
-            #    by calling total_spanning_tree_weight with weight=None
+            #    by calling total_spanning_tree_weight with weight=None.
+            #    Note that with no edges the returned value is just zero.
             else:
                 total = 0
                 for u, v, w in G.edges(data=weight):
@@ -913,6 +914,10 @@ def spanning_tree_total_weight(G, weight):
                     )
                 return total
 
+    if G.number_of_nodes() < 2:
+        # no edges in the spanning tree
+        return nx.empty_graph(G.nodes)
+
     U = set()
     st_cached_value = 0
     V = set(G.edges())
diff --git a/networkx/algorithms/tree/tests/test_mst.py b/networkx/algorithms/tree/tests/test_mst.py
index 373f16cf7a0..bc55000a6e6 100644
--- a/networkx/algorithms/tree/tests/test_mst.py
+++ b/networkx/algorithms/tree/tests/test_mst.py
@@ -706,3 +706,27 @@ def test_random_spanning_tree_additive_large():
     # Assert that p is greater than the significance level so that we do not
     # reject the null hypothesis
     assert not p < 0.05
+
+
+def test_random_spanning_tree_empty_graph():
+    G = nx.Graph()
+    rst = nx.tree.random_spanning_tree(G)
+    assert len(rst.nodes) == 0
+    assert len(rst.edges) == 0
+
+
+def test_random_spanning_tree_single_node_graph():
+    G = nx.Graph()
+    G.add_node(0)
+    rst = nx.tree.random_spanning_tree(G)
+    assert len(rst.nodes) == 1
+    assert len(rst.edges) == 0
+
+
+def test_random_spanning_tree_single_node_loop():
+    G = nx.Graph()
+    G.add_node(0)
+    G.add_edge(0, 0)
+    rst = nx.tree.random_spanning_tree(G)
+    assert len(rst.nodes) == 1
+    assert len(rst.edges) == 0

From 5a7800e7cccc1da85f67c35f3068370f3f588ea5 Mon Sep 17 00:00:00 2001
From: Mauricio Souza de Alencar <856825+mdealencar@users.noreply.github.com>
Date: Thu, 11 Jan 2024 20:00:21 +0100
Subject: [PATCH 037/129] Update methods for modifying edges in PlanarEmbedding
 (#6798)

Implements edge and node removal methods for the PlanarEmbedding class,
with all of the additional checking required to ensure edge attributes are updated
properly.

Also explicitly disallows the methods for adding edges, which may invalidate the
planarity

Co-authored-by: mdealencar <mdealencar@users.noreply.github.com>
Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: mdealencar <DTUnote+mdealencar@users.noreply.github.com>
---
 networkx/algorithms/planarity.py            | 166 +++++++++++++++++++-
 networkx/algorithms/tests/test_planarity.py |  77 +++++++--
 2 files changed, 230 insertions(+), 13 deletions(-)

diff --git a/networkx/algorithms/planarity.py b/networkx/algorithms/planarity.py
index c5611eca39f..59206b412e0 100644
--- a/networkx/algorithms/planarity.py
+++ b/networkx/algorithms/planarity.py
@@ -855,6 +855,22 @@ class PlanarEmbedding(nx.DiGraph):
 
     """
 
+    def __init__(self, incoming_graph_data=None, **attr):
+        super().__init__(incoming_graph_data=incoming_graph_data, **attr)
+        self.add_edge = self.__forbidden
+        self.add_edges_from = self.__forbidden
+        self.add_weighted_edges_from = self.__forbidden
+
+    def __forbidden(self, *args, **kwargs):
+        """Forbidden operation
+
+        Any edge additions to a PlanarEmbedding should be done using
+        method `add_half_edge`.
+        """
+        raise NotImplementedError(
+            "Use `add_half_edge` method to add edges to a PlanarEmbedding."
+        )
+
     def get_data(self):
         """Converts the adjacency structure into a better readable structure.
 
@@ -896,6 +912,75 @@ def set_data(self, data):
                 self.add_half_edge(v, w, cw=ref)
                 ref = w
 
+    def remove_node(self, n):
+        """Remove node n.
+
+        Removes the node n and all adjacent edges, updating the
+        PlanarEmbedding to account for any resulting edge removal.
+        Attempting to remove a non-existent node will raise an exception.
+
+        Parameters
+        ----------
+        n : node
+           A node in the graph
+
+        Raises
+        ------
+        NetworkXError
+           If n is not in the graph.
+
+        See Also
+        --------
+        remove_nodes_from
+
+        """
+        try:
+            for u in self._pred[n]:
+                succs_u = self._succ[u]
+                un_cw = succs_u[n]["cw"]
+                un_ccw = succs_u[n]["ccw"]
+                del succs_u[n]
+                del self._pred[u][n]
+                if n != un_cw:
+                    succs_u[un_cw]["ccw"] = un_ccw
+                    succs_u[un_ccw]["cw"] = un_cw
+            del self._node[n]
+            del self._succ[n]
+            del self._pred[n]
+        except KeyError as err:  # NetworkXError if n not in self
+            raise nx.NetworkXError(
+                f"The node {n} is not in the planar embedding."
+            ) from err
+
+    def remove_nodes_from(self, nodes):
+        """Remove multiple nodes.
+
+        Parameters
+        ----------
+        nodes : iterable container
+            A container of nodes (list, dict, set, etc.).  If a node
+            in the container is not in the graph it is silently ignored.
+
+        See Also
+        --------
+        remove_node
+
+        Notes
+        -----
+        When removing nodes from an iterator over the graph you are changing,
+        a `RuntimeError` will be raised with message:
+        `RuntimeError: dictionary changed size during iteration`. This
+        happens when the graph's underlying dictionary is modified during
+        iteration. To avoid this error, evaluate the iterator into a separate
+        object, e.g. by using `list(iterator_of_nodes)`, and pass this
+        object to `G.remove_nodes_from`.
+
+        """
+        for n in nodes:
+            if n in self._node:
+                self.remove_node(n)
+            # silently skip non-existing nodes
+
     def neighbors_cw_order(self, v):
         """Generator for the neighbors of v in clockwise order.
 
@@ -940,6 +1025,7 @@ def add_half_edge(self, start_node, end_node, *, cw=None, ccw=None):
             End node of reference edge.
             Omit or pass `None` if adding the first out-half-edge of `start_node`.
 
+
         Raises
         ------
         NetworkXException
@@ -962,7 +1048,7 @@ def add_half_edge(self, start_node, end_node, *, cw=None, ccw=None):
                 if ccw is not None:
                     raise nx.NetworkXError("Only one of cw/ccw can be specified.")
                 ref_ccw = succs[cw]["ccw"]
-                self.add_edge(start_node, end_node, cw=cw, ccw=ref_ccw)
+                super().add_edge(start_node, end_node, cw=cw, ccw=ref_ccw)
                 succs[ref_ccw]["cw"] = end_node
                 succs[cw]["ccw"] = end_node
                 # when (cw == leftmost_nbr), the newly added neighbor is
@@ -973,7 +1059,7 @@ def add_half_edge(self, start_node, end_node, *, cw=None, ccw=None):
                 if ccw not in succs:
                     raise nx.NetworkXError("Invalid counterclockwise reference node.")
                 ref_cw = succs[ccw]["cw"]
-                self.add_edge(start_node, end_node, cw=ref_cw, ccw=ccw)
+                super().add_edge(start_node, end_node, cw=ref_cw, ccw=ccw)
                 succs[ref_cw]["ccw"] = end_node
                 succs[ccw]["cw"] = end_node
                 move_leftmost_nbr_to_end = True
@@ -986,11 +1072,12 @@ def add_half_edge(self, start_node, end_node, *, cw=None, ccw=None):
                 # we keep track of the leftmost neighbor, which we accomplish
                 # by keeping it as the last key in dict self._succ[start_node]
                 succs[leftmost_nbr] = succs.pop(leftmost_nbr)
+
         else:
             if cw is not None or ccw is not None:
                 raise nx.NetworkXError("Invalid reference node.")
             # adding the first edge out of start_node
-            self.add_edge(start_node, end_node, ccw=end_node, cw=end_node)
+            super().add_edge(start_node, end_node, ccw=end_node, cw=end_node)
 
     def check_structure(self):
         """Runs without exceptions if this object is valid.
@@ -1107,6 +1194,79 @@ def add_half_edge_cw(self, start_node, end_node, reference_neighbor):
         """
         self.add_half_edge(start_node, end_node, ccw=reference_neighbor)
 
+    def remove_edge(self, u, v):
+        """Remove the edge between u and v.
+
+        Parameters
+        ----------
+        u, v : nodes
+        Remove the half-edges (u, v) and (v, u) and update the
+        edge ordering around the removed edge.
+
+        Raises
+        ------
+        NetworkXError
+        If there is not an edge between u and v.
+
+        See Also
+        --------
+        remove_edges_from : remove a collection of edges
+        """
+        try:
+            succs_u = self._succ[u]
+            succs_v = self._succ[v]
+            uv_cw = succs_u[v]["cw"]
+            uv_ccw = succs_u[v]["ccw"]
+            vu_cw = succs_v[u]["cw"]
+            vu_ccw = succs_v[u]["ccw"]
+            del succs_u[v]
+            del self._pred[v][u]
+            del succs_v[u]
+            del self._pred[u][v]
+            if v != uv_cw:
+                succs_u[uv_cw]["ccw"] = uv_ccw
+                succs_u[uv_ccw]["cw"] = uv_cw
+            if u != vu_cw:
+                succs_v[vu_cw]["ccw"] = vu_ccw
+                succs_v[vu_ccw]["cw"] = vu_cw
+        except KeyError as err:
+            raise nx.NetworkXError(
+                f"The edge {u}-{v} is not in the planar embedding."
+            ) from err
+
+    def remove_edges_from(self, ebunch):
+        """Remove all edges specified in ebunch.
+
+        Parameters
+        ----------
+        ebunch: list or container of edge tuples
+            Each pair of half-edges between the nodes given in the tuples
+            will be removed from the graph. The nodes can be passed as:
+
+                - 2-tuples (u, v) half-edges (u, v) and (v, u).
+                - 3-tuples (u, v, k) where k is ignored.
+
+        See Also
+        --------
+        remove_edge : remove a single edge
+
+        Notes
+        -----
+        Will fail silently if an edge in ebunch is not in the graph.
+
+        Examples
+        --------
+        >>> G = nx.path_graph(4)  # or DiGraph, MultiGraph, MultiDiGraph, etc
+        >>> ebunch = [(1, 2), (2, 3)]
+        >>> G.remove_edges_from(ebunch)
+        """
+        for e in ebunch:
+            u, v = e[:2]  # ignore edge data
+            # assuming that the PlanarEmbedding is valid, if the half_edge
+            # (u, v) is in the graph, then so is half_edge (v, u)
+            if u in self._succ and v in self._succ[u]:
+                self.remove_edge(u, v)
+
     def connect_components(self, v, w):
         """Adds half-edges for (v, w) and (w, v) at some position.
 
diff --git a/networkx/algorithms/tests/test_planarity.py b/networkx/algorithms/tests/test_planarity.py
index 02b1d32a922..99bcff4184a 100644
--- a/networkx/algorithms/tests/test_planarity.py
+++ b/networkx/algorithms/tests/test_planarity.py
@@ -277,6 +277,20 @@ def test_counterexample_planar_recursive(self):
             G.add_node(1)
             get_counterexample_recursive(G)
 
+    def test_edge_removal_from_planar_embedding(self):
+        # PlanarEmbedding.check_structure() must succeed after edge removal
+        edges = ((0, 1), (1, 2), (2, 3), (3, 4), (4, 0), (0, 2), (0, 3))
+        G = nx.Graph(edges)
+        cert, P = nx.check_planarity(G)
+        assert cert is True
+        P.remove_edge(0, 2)
+        self.check_graph(P, is_planar=True)
+        P.add_half_edge_ccw(1, 3, 2)
+        P.add_half_edge_cw(3, 1, 2)
+        self.check_graph(P, is_planar=True)
+        P.remove_edges_from(((0, 3), (1, 3)))
+        self.check_graph(P, is_planar=True)
+
 
 def check_embedding(G, embedding):
     """Raises an exception if the combinatorial embedding is not correct
@@ -410,19 +424,51 @@ def test_get_data(self):
         data_cmp = {0: [3, 2, 1], 1: [0], 2: [0], 3: [0]}
         assert data == data_cmp
 
-    def test_missing_edge_orientation(self):
+    def test_edge_removal(self):
         embedding = nx.PlanarEmbedding()
-        embedding.add_edge(1, 2)
-        embedding.add_edge(2, 1)
+        embedding.set_data(
+            {
+                1: [2, 5, 7],
+                2: [1, 3, 4, 5],
+                3: [2, 4],
+                4: [3, 6, 5, 2],
+                5: [7, 1, 2, 4],
+                6: [4, 7],
+                7: [6, 1, 5],
+            }
+        )
+        # remove_edges_from() calls remove_edge(), so both are tested here
+        embedding.remove_edges_from(((5, 4), (1, 5)))
+        embedding.check_structure()
+        embedding_expected = nx.PlanarEmbedding()
+        embedding_expected.set_data(
+            {
+                1: [2, 7],
+                2: [1, 3, 4, 5],
+                3: [2, 4],
+                4: [3, 6, 2],
+                5: [7, 2],
+                6: [4, 7],
+                7: [6, 1, 5],
+            }
+        )
+        assert nx.utils.graphs_equal(embedding, embedding_expected)
+
+    def test_missing_edge_orientation(self):
+        embedding = nx.PlanarEmbedding({1: {2: {}}, 2: {1: {}}})
         with pytest.raises(nx.NetworkXException):
             # Invalid structure because the orientation of the edge was not set
             embedding.check_structure()
 
     def test_invalid_edge_orientation(self):
-        embedding = nx.PlanarEmbedding()
-        embedding.add_half_edge(1, 2)
-        embedding.add_half_edge(2, 1)
-        embedding.add_edge(1, 3)
+        embedding = nx.PlanarEmbedding(
+            {
+                1: {2: {"cw": 2, "ccw": 2}},
+                2: {1: {"cw": 1, "ccw": 1}},
+                1: {3: {}},
+                3: {1: {}},
+            }
+        )
         with pytest.raises(nx.NetworkXException):
             embedding.check_structure()
 
@@ -461,12 +507,23 @@ def test_successful_face_traversal(self):
         assert face == [1, 2]
 
     def test_unsuccessful_face_traversal(self):
-        embedding = nx.PlanarEmbedding()
-        embedding.add_edge(1, 2, ccw=2, cw=3)
-        embedding.add_edge(2, 1, ccw=1, cw=3)
+        embedding = nx.PlanarEmbedding(
+            {1: {2: {"cw": 3, "ccw": 2}}, 2: {1: {"cw": 3, "ccw": 1}}}
+        )
         with pytest.raises(nx.NetworkXException):
             embedding.traverse_face(1, 2)
 
+    def test_forbidden_methods(self):
+        embedding = nx.PlanarEmbedding()
+        embedding.add_node(42)  # no exception
+        embedding.add_nodes_from([(23, 24)])  # no exception
+        with pytest.raises(NotImplementedError):
+            embedding.add_edge(1, 3)
+        with pytest.raises(NotImplementedError):
+            embedding.add_edges_from([(0, 2), (1, 4)])
+        with pytest.raises(NotImplementedError):
+            embedding.add_weighted_edges_from([(0, 2, 350), (1, 4, 125)])
+
     @staticmethod
     def get_star_embedding(n):
         embedding = nx.PlanarEmbedding()

From 83030a626d50f507e27a88f40b4c6c75b85cb3ae Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Fri, 12 Jan 2024 08:43:49 -0600
Subject: [PATCH 038/129] Rename `_dispatch` to `_dispatchable` (#7193)

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 doc/developer/nxeps/nxep-0003.rst             |  2 +-
 doc/reference/utils.rst                       |  2 +-
 networkx/__init__.py                          |  2 +-
 networkx/algorithms/approximation/clique.py   |  8 +--
 .../approximation/clustering_coefficient.py   |  2 +-
 .../algorithms/approximation/connectivity.py  |  6 +--
 .../approximation/distance_measures.py        |  2 +-
 .../approximation/dominating_set.py           |  4 +-
 .../algorithms/approximation/kcomponents.py   |  2 +-
 networkx/algorithms/approximation/matching.py |  2 +-
 networkx/algorithms/approximation/maxcut.py   |  4 +-
 networkx/algorithms/approximation/ramsey.py   |  2 +-
 .../algorithms/approximation/steinertree.py   |  4 +-
 .../approximation/traveling_salesman.py       | 16 +++---
 .../algorithms/approximation/treewidth.py     |  6 +--
 .../algorithms/approximation/vertex_cover.py  |  2 +-
 .../algorithms/assortativity/connectivity.py  |  2 +-
 .../algorithms/assortativity/correlation.py   |  8 +--
 networkx/algorithms/assortativity/mixing.py   |  8 +--
 .../assortativity/neighbor_degree.py          |  2 +-
 networkx/algorithms/assortativity/pairs.py    |  4 +-
 networkx/algorithms/asteroidal.py             |  6 +--
 networkx/algorithms/bipartite/basic.py        | 12 ++---
 networkx/algorithms/bipartite/centrality.py   |  6 +--
 networkx/algorithms/bipartite/cluster.py      |  6 +--
 networkx/algorithms/bipartite/covering.py     |  2 +-
 networkx/algorithms/bipartite/edgelist.py     |  4 +-
 networkx/algorithms/bipartite/generators.py   | 16 +++---
 networkx/algorithms/bipartite/matching.py     |  8 +--
 networkx/algorithms/bipartite/matrix.py       |  4 +-
 networkx/algorithms/bipartite/projection.py   | 10 ++--
 networkx/algorithms/bipartite/redundancy.py   |  2 +-
 networkx/algorithms/bipartite/spectral.py     |  2 +-
 networkx/algorithms/boundary.py               |  4 +-
 networkx/algorithms/bridges.py                |  6 +--
 networkx/algorithms/centrality/betweenness.py |  4 +-
 .../centrality/betweenness_subset.py          |  4 +-
 networkx/algorithms/centrality/closeness.py   |  4 +-
 .../centrality/current_flow_betweenness.py    |  6 +--
 .../current_flow_betweenness_subset.py        |  4 +-
 .../centrality/current_flow_closeness.py      |  2 +-
 networkx/algorithms/centrality/degree_alg.py  |  6 +--
 networkx/algorithms/centrality/dispersion.py  |  2 +-
 networkx/algorithms/centrality/eigenvector.py |  4 +-
 networkx/algorithms/centrality/flow_matrix.py |  2 +-
 networkx/algorithms/centrality/group.py       | 12 ++---
 networkx/algorithms/centrality/harmonic.py    |  2 +-
 networkx/algorithms/centrality/katz.py        |  4 +-
 networkx/algorithms/centrality/laplacian.py   |  2 +-
 networkx/algorithms/centrality/load.py        |  4 +-
 networkx/algorithms/centrality/percolation.py |  2 +-
 networkx/algorithms/centrality/reaching.py    |  4 +-
 .../algorithms/centrality/second_order.py     |  2 +-
 .../algorithms/centrality/subgraph_alg.py     |  8 +--
 networkx/algorithms/centrality/trophic.py     |  6 +--
 .../algorithms/centrality/voterank_alg.py     |  2 +-
 networkx/algorithms/chains.py                 |  2 +-
 networkx/algorithms/chordal.py                | 10 ++--
 networkx/algorithms/clique.py                 | 14 +++---
 networkx/algorithms/cluster.py                | 12 ++---
 .../algorithms/coloring/equitable_coloring.py |  8 +--
 .../algorithms/coloring/greedy_coloring.py    | 18 +++----
 networkx/algorithms/communicability_alg.py    |  4 +-
 networkx/algorithms/community/asyn_fluid.py   |  2 +-
 networkx/algorithms/community/centrality.py   |  2 +-
 .../algorithms/community/community_utils.py   |  2 +-
 networkx/algorithms/community/kclique.py      |  2 +-
 .../algorithms/community/kernighan_lin.py     |  2 +-
 .../algorithms/community/label_propagation.py |  6 +--
 networkx/algorithms/community/louvain.py      |  4 +-
 networkx/algorithms/community/lukes.py        |  2 +-
 .../algorithms/community/modularity_max.py    |  4 +-
 networkx/algorithms/community/quality.py      | 10 ++--
 networkx/algorithms/components/attracting.py  |  6 +--
 networkx/algorithms/components/biconnected.py |  8 +--
 networkx/algorithms/components/connected.py   |  8 +--
 .../algorithms/components/semiconnected.py    |  2 +-
 .../components/strongly_connected.py          | 12 ++---
 .../components/tests/test_connected.py        |  2 +-
 .../algorithms/components/weakly_connected.py |  6 +--
 .../algorithms/connectivity/connectivity.py   | 12 ++---
 networkx/algorithms/connectivity/cuts.py      |  8 +--
 .../algorithms/connectivity/disjoint_paths.py |  4 +-
 .../connectivity/edge_augmentation.py         | 26 +++++-----
 .../connectivity/edge_kcomponents.py          |  8 +--
 .../algorithms/connectivity/kcomponents.py    |  2 +-
 networkx/algorithms/connectivity/kcutsets.py  |  2 +-
 .../algorithms/connectivity/stoerwagner.py    |  2 +-
 networkx/algorithms/connectivity/utils.py     |  4 +-
 networkx/algorithms/core.py                   | 14 +++---
 networkx/algorithms/covering.py               |  4 +-
 networkx/algorithms/cuts.py                   | 16 +++---
 networkx/algorithms/cycles.py                 | 14 +++---
 networkx/algorithms/d_separation.py           |  6 +--
 networkx/algorithms/dag.py                    | 36 ++++++-------
 networkx/algorithms/distance_measures.py      | 18 +++----
 networkx/algorithms/distance_regular.py       |  6 +--
 networkx/algorithms/dominance.py              |  4 +-
 networkx/algorithms/dominating.py             |  4 +-
 networkx/algorithms/efficiency_measures.py    |  6 +--
 networkx/algorithms/euler.py                  | 12 ++---
 networkx/algorithms/flow/boykovkolmogorov.py  |  2 +-
 networkx/algorithms/flow/capacityscaling.py   |  4 +-
 networkx/algorithms/flow/dinitz_alg.py        |  2 +-
 networkx/algorithms/flow/edmondskarp.py       |  4 +-
 networkx/algorithms/flow/gomory_hu.py         |  2 +-
 networkx/algorithms/flow/maxflow.py           |  8 +--
 networkx/algorithms/flow/mincost.py           | 12 +++--
 networkx/algorithms/flow/networksimplex.py    |  4 +-
 networkx/algorithms/flow/preflowpush.py       |  2 +-
 .../algorithms/flow/shortestaugmentingpath.py |  2 +-
 networkx/algorithms/flow/utils.py             |  6 +--
 networkx/algorithms/graph_hashing.py          |  4 +-
 networkx/algorithms/graphical.py              | 12 ++---
 networkx/algorithms/hierarchy.py              |  2 +-
 networkx/algorithms/hybrid.py                 |  4 +-
 networkx/algorithms/isolate.py                |  6 +--
 networkx/algorithms/isomorphism/isomorph.py   |  8 +--
 .../isomorphism/tree_isomorphism.py           |  8 +--
 networkx/algorithms/isomorphism/vf2pp.py      |  6 +--
 networkx/algorithms/link_analysis/hits_alg.py |  2 +-
 .../algorithms/link_analysis/pagerank_alg.py  |  4 +-
 .../link_analysis/tests/test_pagerank.py      |  2 +-
 networkx/algorithms/link_prediction.py        | 16 +++---
 .../algorithms/lowest_common_ancestors.py     |  6 +--
 networkx/algorithms/matching.py               | 12 ++---
 networkx/algorithms/minors/contraction.py     |  6 +--
 networkx/algorithms/mis.py                    |  2 +-
 networkx/algorithms/moral.py                  |  2 +-
 networkx/algorithms/node_classification.py    |  4 +-
 networkx/algorithms/non_randomness.py         |  2 +-
 networkx/algorithms/operators/all.py          |  8 +--
 networkx/algorithms/operators/binary.py       | 14 +++---
 networkx/algorithms/operators/product.py      | 14 +++---
 .../algorithms/operators/tests/test_binary.py |  4 +-
 networkx/algorithms/operators/unary.py        |  4 +-
 networkx/algorithms/planarity.py              | 10 ++--
 networkx/algorithms/polynomials.py            |  4 +-
 networkx/algorithms/reciprocity.py            |  4 +-
 networkx/algorithms/regular.py                |  6 +--
 networkx/algorithms/richclub.py               |  2 +-
 networkx/algorithms/shortest_paths/astar.py   |  4 +-
 networkx/algorithms/shortest_paths/dense.py   |  8 +--
 networkx/algorithms/shortest_paths/generic.py | 14 +++---
 .../algorithms/shortest_paths/unweighted.py   | 16 +++---
 .../algorithms/shortest_paths/weighted.py     | 50 +++++++++----------
 networkx/algorithms/similarity.py             | 14 +++---
 networkx/algorithms/simple_paths.py           |  8 +--
 networkx/algorithms/smallworld.py             |  8 +--
 networkx/algorithms/smetric.py                |  2 +-
 networkx/algorithms/sparsifiers.py            |  2 +-
 networkx/algorithms/structuralholes.py        | 10 ++--
 networkx/algorithms/summarization.py          |  4 +-
 networkx/algorithms/swap.py                   |  6 +--
 .../algorithms/tests/test_structuralholes.py  |  2 +-
 networkx/algorithms/threshold.py              | 10 ++--
 networkx/algorithms/time_dependent.py         |  2 +-
 networkx/algorithms/tournament.py             | 14 +++---
 networkx/algorithms/traversal/beamsearch.py   |  2 +-
 .../traversal/breadth_first_search.py         | 16 +++---
 .../traversal/depth_first_search.py           | 14 +++---
 networkx/algorithms/traversal/edgebfs.py      |  2 +-
 networkx/algorithms/traversal/edgedfs.py      |  2 +-
 networkx/algorithms/tree/branchings.py        | 14 +++---
 networkx/algorithms/tree/coding.py            |  8 +--
 networkx/algorithms/tree/decomposition.py     |  2 +-
 networkx/algorithms/tree/mst.py               | 18 +++----
 networkx/algorithms/tree/operations.py        |  2 +-
 networkx/algorithms/tree/recognition.py       |  8 +--
 networkx/algorithms/triads.py                 | 14 +++---
 networkx/algorithms/vitality.py               |  2 +-
 networkx/algorithms/voronoi.py                |  2 +-
 networkx/algorithms/walks.py                  |  2 +-
 networkx/algorithms/wiener.py                 |  2 +-
 networkx/classes/tests/dispatch_interface.py  |  2 +-
 networkx/classes/tests/test_backends.py       |  4 +-
 networkx/conftest.py                          |  8 +--
 networkx/convert.py                           | 10 ++--
 networkx/convert_matrix.py                    | 16 +++---
 networkx/drawing/nx_agraph.py                 |  4 +-
 networkx/drawing/nx_pydot.py                  |  4 +-
 networkx/generators/atlas.py                  |  4 +-
 networkx/generators/classic.py                | 40 +++++++--------
 networkx/generators/cographs.py               |  2 +-
 networkx/generators/community.py              | 20 ++++----
 networkx/generators/degree_seq.py             | 14 +++---
 networkx/generators/directed.py               | 12 ++---
 networkx/generators/duplication.py            |  4 +-
 networkx/generators/ego.py                    |  2 +-
 networkx/generators/expanders.py              |  6 +--
 networkx/generators/geometric.py              | 16 +++---
 networkx/generators/harary_graph.py           |  4 +-
 networkx/generators/internet_as_graphs.py     |  2 +-
 networkx/generators/intersection.py           |  6 +--
 networkx/generators/interval_graph.py         |  2 +-
 networkx/generators/joint_degree_seq.py       |  8 +--
 networkx/generators/lattice.py                | 10 ++--
 networkx/generators/line.py                   |  4 +-
 networkx/generators/mycielski.py              |  4 +-
 networkx/generators/nonisomorphic_trees.py    |  4 +-
 networkx/generators/random_clustered.py       |  2 +-
 networkx/generators/random_graphs.py          | 34 ++++++-------
 networkx/generators/small.py                  | 46 ++++++++---------
 networkx/generators/social.py                 |  8 +--
 networkx/generators/spectral_graph_forge.py   |  2 +-
 networkx/generators/stochastic.py             |  2 +-
 networkx/generators/sudoku.py                 |  2 +-
 networkx/generators/time_series.py            |  2 +-
 networkx/generators/trees.py                  | 18 +++----
 networkx/generators/triads.py                 |  2 +-
 networkx/linalg/algebraicconnectivity.py      |  8 +--
 networkx/linalg/attrmatrix.py                 |  4 +-
 networkx/linalg/bethehessianmatrix.py         |  2 +-
 networkx/linalg/graphmatrix.py                |  4 +-
 networkx/linalg/laplacianmatrix.py            | 10 ++--
 networkx/linalg/modularitymatrix.py           |  4 +-
 networkx/linalg/spectrum.py                   | 10 ++--
 networkx/readwrite/adjlist.py                 |  4 +-
 networkx/readwrite/edgelist.py                |  6 +--
 networkx/readwrite/gexf.py                    |  2 +-
 networkx/readwrite/gml.py                     |  4 +-
 networkx/readwrite/graph6.py                  |  4 +-
 networkx/readwrite/graphml.py                 |  4 +-
 networkx/readwrite/json_graph/adjacency.py    |  2 +-
 networkx/readwrite/json_graph/cytoscape.py    |  2 +-
 networkx/readwrite/json_graph/node_link.py    |  2 +-
 networkx/readwrite/json_graph/tree.py         |  2 +-
 networkx/readwrite/leda.py                    |  4 +-
 networkx/readwrite/multiline_adjlist.py       |  4 +-
 networkx/readwrite/p2g.py                     |  4 +-
 networkx/readwrite/pajek.py                   |  4 +-
 networkx/readwrite/sparse6.py                 |  4 +-
 networkx/relabel.py                           |  4 +-
 networkx/utils/backends.py                    | 38 +++++++-------
 234 files changed, 802 insertions(+), 794 deletions(-)

diff --git a/doc/developer/nxeps/nxep-0003.rst b/doc/developer/nxeps/nxep-0003.rst
index f3971ef3bbf..94916e117f5 100644
--- a/doc/developer/nxeps/nxep-0003.rst
+++ b/doc/developer/nxeps/nxep-0003.rst
@@ -290,7 +290,7 @@ Related Work
 
 This proposal is based on ideas and discussions from #3036 and #1393.
 
-This proposal does not delve into backends using the `_dispatch` functionality
+This proposal does not delve into backends using the `_dispatchable` functionality
 and whether we should be providing or allowing control over the builder
 functions for backend libraries. This is a potentially helpful discussion
 but is beyond the scope of this NXEP.
diff --git a/doc/reference/utils.rst b/doc/reference/utils.rst
index 21ae064076e..acd9c92584e 100644
--- a/doc/reference/utils.rst
+++ b/doc/reference/utils.rst
@@ -85,4 +85,4 @@ Backends
 .. autosummary::
    :toctree: generated/
 
-   _dispatch
+   _dispatchable
diff --git a/networkx/__init__.py b/networkx/__init__.py
index 34bb47f8cde..72d2ef6562f 100644
--- a/networkx/__init__.py
+++ b/networkx/__init__.py
@@ -17,7 +17,7 @@
 from networkx.exception import *
 
 from networkx import utils
-from networkx.utils.backends import _dispatch
+from networkx.utils.backends import _dispatchable
 
 from networkx import classes
 from networkx.classes import filters
diff --git a/networkx/algorithms/approximation/clique.py b/networkx/algorithms/approximation/clique.py
index 4a3d8beba61..56443068633 100644
--- a/networkx/algorithms/approximation/clique.py
+++ b/networkx/algorithms/approximation/clique.py
@@ -13,7 +13,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def maximum_independent_set(G):
     """Returns an approximate maximum independent set.
 
@@ -70,7 +70,7 @@ def maximum_independent_set(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def max_clique(G):
     r"""Find the Maximum Clique
 
@@ -129,7 +129,7 @@ def max_clique(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def clique_removal(G):
     r"""Repeatedly remove cliques from the graph.
 
@@ -182,7 +182,7 @@ def clique_removal(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def large_clique_size(G):
     """Find the size of a large clique in a graph.
 
diff --git a/networkx/algorithms/approximation/clustering_coefficient.py b/networkx/algorithms/approximation/clustering_coefficient.py
index e15ac68460b..f95c86d2a91 100644
--- a/networkx/algorithms/approximation/clustering_coefficient.py
+++ b/networkx/algorithms/approximation/clustering_coefficient.py
@@ -6,7 +6,7 @@
 
 @not_implemented_for("directed")
 @py_random_state(2)
-@nx._dispatch(name="approximate_average_clustering")
+@nx._dispatchable(name="approximate_average_clustering")
 def average_clustering(G, trials=1000, seed=None):
     r"""Estimates the average clustering coefficient of G.
 
diff --git a/networkx/algorithms/approximation/connectivity.py b/networkx/algorithms/approximation/connectivity.py
index bc5e7125937..a2214ed128b 100644
--- a/networkx/algorithms/approximation/connectivity.py
+++ b/networkx/algorithms/approximation/connectivity.py
@@ -12,7 +12,7 @@
 ]
 
 
-@nx._dispatch(name="approximate_local_node_connectivity")
+@nx._dispatchable(name="approximate_local_node_connectivity")
 def local_node_connectivity(G, source, target, cutoff=None):
     """Compute node connectivity between source and target.
 
@@ -108,7 +108,7 @@ def local_node_connectivity(G, source, target, cutoff=None):
     return K
 
 
-@nx._dispatch(name="approximate_node_connectivity")
+@nx._dispatchable(name="approximate_node_connectivity")
 def node_connectivity(G, s=None, t=None):
     r"""Returns an approximation for node connectivity for a graph or digraph G.
 
@@ -214,7 +214,7 @@ def neighbors(v):
     return K
 
 
-@nx._dispatch(name="approximate_all_pairs_node_connectivity")
+@nx._dispatchable(name="approximate_all_pairs_node_connectivity")
 def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):
     """Compute node connectivity between all pairs of nodes.
 
diff --git a/networkx/algorithms/approximation/distance_measures.py b/networkx/algorithms/approximation/distance_measures.py
index 9b817b3317c..a6fece661b1 100644
--- a/networkx/algorithms/approximation/distance_measures.py
+++ b/networkx/algorithms/approximation/distance_measures.py
@@ -7,7 +7,7 @@
 
 
 @py_random_state(1)
-@nx._dispatch(name="approximate_diameter")
+@nx._dispatchable(name="approximate_diameter")
 def diameter(G, seed=None):
     """Returns a lower bound on the diameter of the graph G.
 
diff --git a/networkx/algorithms/approximation/dominating_set.py b/networkx/algorithms/approximation/dominating_set.py
index 97edb172f94..691564cf9dc 100644
--- a/networkx/algorithms/approximation/dominating_set.py
+++ b/networkx/algorithms/approximation/dominating_set.py
@@ -20,7 +20,7 @@
 
 # TODO Why doesn't this algorithm work for directed graphs?
 @not_implemented_for("directed")
-@nx._dispatch(node_attrs="weight")
+@nx._dispatchable(node_attrs="weight")
 def min_weighted_dominating_set(G, weight=None):
     r"""Returns a dominating set that approximates the minimum weight node
     dominating set.
@@ -101,7 +101,7 @@ def _cost(node_and_neighborhood):
     return dom_set
 
 
-@nx._dispatch
+@nx._dispatchable
 def min_edge_dominating_set(G):
     r"""Returns minimum cardinality edge dominating set.
 
diff --git a/networkx/algorithms/approximation/kcomponents.py b/networkx/algorithms/approximation/kcomponents.py
index a5df6cc686c..b540bd5f4a6 100644
--- a/networkx/algorithms/approximation/kcomponents.py
+++ b/networkx/algorithms/approximation/kcomponents.py
@@ -14,7 +14,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch(name="approximate_k_components")
+@nx._dispatchable(name="approximate_k_components")
 def k_components(G, min_density=0.95):
     r"""Returns the approximate k-component structure of a graph G.
 
diff --git a/networkx/algorithms/approximation/matching.py b/networkx/algorithms/approximation/matching.py
index 8f1c3501666..3a7c8a39b2e 100644
--- a/networkx/algorithms/approximation/matching.py
+++ b/networkx/algorithms/approximation/matching.py
@@ -13,7 +13,7 @@
 __all__ = ["min_maximal_matching"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def min_maximal_matching(G):
     r"""Returns the minimum maximal matching of G. That is, out of all maximal
     matchings of the graph G, the smallest is returned.
diff --git a/networkx/algorithms/approximation/maxcut.py b/networkx/algorithms/approximation/maxcut.py
index 31ccdc9fde3..0c30d224d2f 100644
--- a/networkx/algorithms/approximation/maxcut.py
+++ b/networkx/algorithms/approximation/maxcut.py
@@ -7,7 +7,7 @@
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(1)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def randomized_partitioning(G, seed=None, p=0.5, weight=None):
     """Compute a random partitioning of the graph nodes and its cut value.
 
@@ -53,7 +53,7 @@ def _swap_node_partition(cut, node):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(2)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def one_exchange(G, initial_cut=None, seed=None, weight=None):
     """Compute a partitioning of the graphs nodes and the corresponding cut value.
 
diff --git a/networkx/algorithms/approximation/ramsey.py b/networkx/algorithms/approximation/ramsey.py
index 6f45c4f4971..5cb9fda0449 100644
--- a/networkx/algorithms/approximation/ramsey.py
+++ b/networkx/algorithms/approximation/ramsey.py
@@ -11,7 +11,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def ramsey_R2(G):
     r"""Compute the largest clique and largest independent set in `G`.
 
diff --git a/networkx/algorithms/approximation/steinertree.py b/networkx/algorithms/approximation/steinertree.py
index 50aea045fea..7751251ddf8 100644
--- a/networkx/algorithms/approximation/steinertree.py
+++ b/networkx/algorithms/approximation/steinertree.py
@@ -7,7 +7,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def metric_closure(G, weight="weight"):
     """Return the metric closure of a graph.
 
@@ -126,7 +126,7 @@ def _remove_nonterminal_leaves(G, terminals):
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def steiner_tree(G, terminal_nodes, weight="weight", method=None):
     r"""Return an approximation to the minimum Steiner tree of a graph.
 
diff --git a/networkx/algorithms/approximation/traveling_salesman.py b/networkx/algorithms/approximation/traveling_salesman.py
index 2164ea25db6..111ed7d60c7 100644
--- a/networkx/algorithms/approximation/traveling_salesman.py
+++ b/networkx/algorithms/approximation/traveling_salesman.py
@@ -124,7 +124,7 @@ def move_one_node(soln, seed):
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def christofides(G, weight="weight", tree=None):
     """Approximate a solution of the traveling salesman problem
 
@@ -197,7 +197,7 @@ def _shortcutting(circuit):
     return nodes
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def traveling_salesman_problem(G, weight="weight", nodes=None, cycle=True, method=None):
     """Find the shortest path in `G` connecting specified nodes
 
@@ -340,7 +340,7 @@ def traveling_salesman_problem(G, weight="weight", nodes=None, cycle=True, metho
 
 @not_implemented_for("undirected")
 @py_random_state(2)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def asadpour_atsp(G, weight="weight", seed=None, source=None):
     """
     Returns an approximate solution to the traveling salesman problem.
@@ -490,7 +490,7 @@ def asadpour_atsp(G, weight="weight", seed=None, source=None):
     return _shortcutting(circuit)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def held_karp_ascent(G, weight="weight"):
     """
     Minimizes the Held-Karp relaxation of the TSP for `G`
@@ -801,7 +801,7 @@ def find_epsilon(k, d):
     return next(k_max.__iter__()).size(weight), z_star
 
 
-@nx._dispatch
+@nx._dispatchable
 def spanning_tree_distribution(G, z):
     """
     Find the asadpour exponential distribution of spanning trees.
@@ -912,7 +912,7 @@ def q(e):
     return gamma
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def greedy_tsp(G, weight="weight", source=None):
     """Return a low cost cycle starting at `source` and its cost.
 
@@ -1005,7 +1005,7 @@ def greedy_tsp(G, weight="weight", source=None):
 
 
 @py_random_state(9)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def simulated_annealing_tsp(
     G,
     init_cycle,
@@ -1224,7 +1224,7 @@ def simulated_annealing_tsp(
 
 
 @py_random_state(9)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def threshold_accepting_tsp(
     G,
     init_cycle,
diff --git a/networkx/algorithms/approximation/treewidth.py b/networkx/algorithms/approximation/treewidth.py
index 89ac39ce67d..c7c01a1cd4d 100644
--- a/networkx/algorithms/approximation/treewidth.py
+++ b/networkx/algorithms/approximation/treewidth.py
@@ -41,7 +41,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def treewidth_min_degree(G):
     """Returns a treewidth decomposition using the Minimum Degree heuristic.
 
@@ -65,7 +65,7 @@ def treewidth_min_degree(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def treewidth_min_fill_in(G):
     """Returns a treewidth decomposition using the Minimum Fill-in heuristic.
 
@@ -177,7 +177,7 @@ def min_fill_in_heuristic(graph):
     return min_fill_in_node
 
 
-@nx._dispatch
+@nx._dispatchable
 def treewidth_decomp(G, heuristic=min_fill_in_heuristic):
     """Returns a treewidth decomposition using the passed heuristic.
 
diff --git a/networkx/algorithms/approximation/vertex_cover.py b/networkx/algorithms/approximation/vertex_cover.py
index dbd7a123d02..c71399ebcc9 100644
--- a/networkx/algorithms/approximation/vertex_cover.py
+++ b/networkx/algorithms/approximation/vertex_cover.py
@@ -12,7 +12,7 @@
 __all__ = ["min_weighted_vertex_cover"]
 
 
-@nx._dispatch(node_attrs="weight")
+@nx._dispatchable(node_attrs="weight")
 def min_weighted_vertex_cover(G, weight=None):
     r"""Returns an approximate minimum weighted vertex cover.
 
diff --git a/networkx/algorithms/assortativity/connectivity.py b/networkx/algorithms/assortativity/connectivity.py
index bd433ded595..c3fde0da68a 100644
--- a/networkx/algorithms/assortativity/connectivity.py
+++ b/networkx/algorithms/assortativity/connectivity.py
@@ -5,7 +5,7 @@
 __all__ = ["average_degree_connectivity"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def average_degree_connectivity(
     G, source="in+out", target="in+out", nodes=None, weight=None
 ):
diff --git a/networkx/algorithms/assortativity/correlation.py b/networkx/algorithms/assortativity/correlation.py
index d517132ff21..c62e92f9c2e 100644
--- a/networkx/algorithms/assortativity/correlation.py
+++ b/networkx/algorithms/assortativity/correlation.py
@@ -15,7 +15,7 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def degree_assortativity_coefficient(G, x="out", y="in", weight=None, nodes=None):
     """Compute degree assortativity of graph.
 
@@ -100,7 +100,7 @@ def degree_assortativity_coefficient(G, x="out", y="in", weight=None, nodes=None
     return _numeric_ac(M, mapping=mapping)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def degree_pearson_correlation_coefficient(G, x="out", y="in", weight=None, nodes=None):
     """Compute degree assortativity of graph.
 
@@ -159,7 +159,7 @@ def degree_pearson_correlation_coefficient(G, x="out", y="in", weight=None, node
     return sp.stats.pearsonr(x, y)[0]
 
 
-@nx._dispatch(node_attrs="attribute")
+@nx._dispatchable(node_attrs="attribute")
 def attribute_assortativity_coefficient(G, attribute, nodes=None):
     """Compute assortativity for node attributes.
 
@@ -206,7 +206,7 @@ def attribute_assortativity_coefficient(G, attribute, nodes=None):
     return attribute_ac(M)
 
 
-@nx._dispatch(node_attrs="attribute")
+@nx._dispatchable(node_attrs="attribute")
 def numeric_assortativity_coefficient(G, attribute, nodes=None):
     """Compute assortativity for numerical node attributes.
 
diff --git a/networkx/algorithms/assortativity/mixing.py b/networkx/algorithms/assortativity/mixing.py
index 66b98797e69..577f5da56a9 100644
--- a/networkx/algorithms/assortativity/mixing.py
+++ b/networkx/algorithms/assortativity/mixing.py
@@ -14,7 +14,7 @@
 ]
 
 
-@nx._dispatch(node_attrs="attribute")
+@nx._dispatchable(node_attrs="attribute")
 def attribute_mixing_dict(G, attribute, nodes=None, normalized=False):
     """Returns dictionary representation of mixing matrix for attribute.
 
@@ -53,7 +53,7 @@ def attribute_mixing_dict(G, attribute, nodes=None, normalized=False):
     return mixing_dict(xy_iter, normalized=normalized)
 
 
-@nx._dispatch(node_attrs="attribute")
+@nx._dispatchable(node_attrs="attribute")
 def attribute_mixing_matrix(G, attribute, nodes=None, mapping=None, normalized=True):
     """Returns mixing matrix for attribute.
 
@@ -113,7 +113,7 @@ def attribute_mixing_matrix(G, attribute, nodes=None, mapping=None, normalized=T
     return a
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def degree_mixing_dict(G, x="out", y="in", weight=None, nodes=None, normalized=False):
     """Returns dictionary representation of mixing matrix for degree.
 
@@ -145,7 +145,7 @@ def degree_mixing_dict(G, x="out", y="in", weight=None, nodes=None, normalized=F
     return mixing_dict(xy_iter, normalized=normalized)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def degree_mixing_matrix(
     G, x="out", y="in", weight=None, nodes=None, normalized=True, mapping=None
 ):
diff --git a/networkx/algorithms/assortativity/neighbor_degree.py b/networkx/algorithms/assortativity/neighbor_degree.py
index a8980da766f..6488d041a8b 100644
--- a/networkx/algorithms/assortativity/neighbor_degree.py
+++ b/networkx/algorithms/assortativity/neighbor_degree.py
@@ -3,7 +3,7 @@
 __all__ = ["average_neighbor_degree"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def average_neighbor_degree(G, source="out", target="out", nodes=None, weight=None):
     r"""Returns the average degree of the neighborhood of each node.
 
diff --git a/networkx/algorithms/assortativity/pairs.py b/networkx/algorithms/assortativity/pairs.py
index a3580d40324..5a1d6f8e1df 100644
--- a/networkx/algorithms/assortativity/pairs.py
+++ b/networkx/algorithms/assortativity/pairs.py
@@ -4,7 +4,7 @@
 __all__ = ["node_attribute_xy", "node_degree_xy"]
 
 
-@nx._dispatch(node_attrs="attribute")
+@nx._dispatchable(node_attrs="attribute")
 def node_attribute_xy(G, attribute, nodes=None):
     """Returns iterator of node-attribute pairs for all edges in G.
 
@@ -59,7 +59,7 @@ def node_attribute_xy(G, attribute, nodes=None):
                 yield (uattr, vattr)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def node_degree_xy(G, x="out", y="in", weight=None, nodes=None):
     """Generate node degree-degree pairs for edges in G.
 
diff --git a/networkx/algorithms/asteroidal.py b/networkx/algorithms/asteroidal.py
index 65355fe6253..41e91390dff 100644
--- a/networkx/algorithms/asteroidal.py
+++ b/networkx/algorithms/asteroidal.py
@@ -18,7 +18,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def find_asteroidal_triple(G):
     r"""Find an asteroidal triple in the given graph.
 
@@ -91,7 +91,7 @@ def find_asteroidal_triple(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def is_at_free(G):
     """Check if a graph is AT-free.
 
@@ -125,7 +125,7 @@ def is_at_free(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def create_component_structure(G):
     r"""Create component structure for G.
 
diff --git a/networkx/algorithms/bipartite/basic.py b/networkx/algorithms/bipartite/basic.py
index 8b9120e27aa..d0a63a10fd1 100644
--- a/networkx/algorithms/bipartite/basic.py
+++ b/networkx/algorithms/bipartite/basic.py
@@ -17,7 +17,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def color(G):
     """Returns a two-coloring of the graph.
 
@@ -83,7 +83,7 @@ def neighbors(v):
     return color
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_bipartite(G):
     """Returns True if graph G is bipartite, False if not.
 
@@ -109,7 +109,7 @@ def is_bipartite(G):
         return False
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_bipartite_node_set(G, nodes):
     """Returns True if nodes and G/nodes are a bipartition of G.
 
@@ -154,7 +154,7 @@ def is_bipartite_node_set(G, nodes):
     return True
 
 
-@nx._dispatch
+@nx._dispatchable
 def sets(G, top_nodes=None):
     """Returns bipartite node sets of graph G.
 
@@ -221,7 +221,7 @@ def sets(G, top_nodes=None):
     return (X, Y)
 
 
-@nx._dispatch(graphs="B")
+@nx._dispatchable(graphs="B")
 def density(B, nodes):
     """Returns density of bipartite graph B.
 
@@ -274,7 +274,7 @@ def density(B, nodes):
     return d
 
 
-@nx._dispatch(graphs="B", edge_attrs="weight")
+@nx._dispatchable(graphs="B", edge_attrs="weight")
 def degrees(B, nodes, weight=None):
     """Returns the degrees of the two node sets in the bipartite graph B.
 
diff --git a/networkx/algorithms/bipartite/centrality.py b/networkx/algorithms/bipartite/centrality.py
index a904da3528f..42d7270ee7d 100644
--- a/networkx/algorithms/bipartite/centrality.py
+++ b/networkx/algorithms/bipartite/centrality.py
@@ -3,7 +3,7 @@
 __all__ = ["degree_centrality", "betweenness_centrality", "closeness_centrality"]
 
 
-@nx._dispatch(name="bipartite_degree_centrality")
+@nx._dispatchable(name="bipartite_degree_centrality")
 def degree_centrality(G, nodes):
     r"""Compute the degree centrality for nodes in a bipartite network.
 
@@ -78,7 +78,7 @@ def degree_centrality(G, nodes):
     return centrality
 
 
-@nx._dispatch(name="bipartite_betweenness_centrality")
+@nx._dispatchable(name="bipartite_betweenness_centrality")
 def betweenness_centrality(G, nodes):
     r"""Compute betweenness centrality for nodes in a bipartite network.
 
@@ -182,7 +182,7 @@ def betweenness_centrality(G, nodes):
     return betweenness
 
 
-@nx._dispatch(name="bipartite_closeness_centrality")
+@nx._dispatchable(name="bipartite_closeness_centrality")
 def closeness_centrality(G, nodes, normalized=True):
     r"""Compute the closeness centrality for nodes in a bipartite network.
 
diff --git a/networkx/algorithms/bipartite/cluster.py b/networkx/algorithms/bipartite/cluster.py
index f10d7efd117..d9611527759 100644
--- a/networkx/algorithms/bipartite/cluster.py
+++ b/networkx/algorithms/bipartite/cluster.py
@@ -29,7 +29,7 @@ def cc_min(nu, nv):
 modes = {"dot": cc_dot, "min": cc_min, "max": cc_max}
 
 
-@nx._dispatch
+@nx._dispatchable
 def latapy_clustering(G, nodes=None, mode="dot"):
     r"""Compute a bipartite clustering coefficient for nodes.
 
@@ -134,7 +134,7 @@ def latapy_clustering(G, nodes=None, mode="dot"):
 clustering = latapy_clustering
 
 
-@nx._dispatch(name="bipartite_average_clustering")
+@nx._dispatchable(name="bipartite_average_clustering")
 def average_clustering(G, nodes=None, mode="dot"):
     r"""Compute the average bipartite clustering coefficient.
 
@@ -211,7 +211,7 @@ def average_clustering(G, nodes=None, mode="dot"):
     return sum(ccs[v] for v in nodes) / len(nodes)
 
 
-@nx._dispatch
+@nx._dispatchable
 def robins_alexander_clustering(G):
     r"""Compute the bipartite clustering of G.
 
diff --git a/networkx/algorithms/bipartite/covering.py b/networkx/algorithms/bipartite/covering.py
index 8669b4b1681..720c63ac40c 100644
--- a/networkx/algorithms/bipartite/covering.py
+++ b/networkx/algorithms/bipartite/covering.py
@@ -10,7 +10,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(name="bipartite_min_edge_cover")
+@nx._dispatchable(name="bipartite_min_edge_cover")
 def min_edge_cover(G, matching_algorithm=None):
     """Returns a set of edges which constitutes
     the minimum edge cover of the graph.
diff --git a/networkx/algorithms/bipartite/edgelist.py b/networkx/algorithms/bipartite/edgelist.py
index 90c449a3a14..b9b2a82e05a 100644
--- a/networkx/algorithms/bipartite/edgelist.py
+++ b/networkx/algorithms/bipartite/edgelist.py
@@ -146,7 +146,7 @@ def generate_edgelist(G, delimiter=" ", data=True):
                 yield delimiter.join(map(str, edge))
 
 
-@nx._dispatch(name="bipartite_parse_edgelist", graphs=None)
+@nx._dispatchable(name="bipartite_parse_edgelist", graphs=None)
 def parse_edgelist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
 ):
@@ -268,7 +268,7 @@ def parse_edgelist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(name="bipartite_read_edgelist", graphs=None)
+@nx._dispatchable(name="bipartite_read_edgelist", graphs=None)
 def read_edgelist(
     path,
     comments="#",
diff --git a/networkx/algorithms/bipartite/generators.py b/networkx/algorithms/bipartite/generators.py
index 9c8bfc0ef29..2774c6fd409 100644
--- a/networkx/algorithms/bipartite/generators.py
+++ b/networkx/algorithms/bipartite/generators.py
@@ -20,7 +20,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number([0, 1])
 def complete_bipartite_graph(n1, n2, create_using=None):
     """Returns the complete bipartite graph `K_{n_1,n_2}`.
@@ -67,7 +67,7 @@ def complete_bipartite_graph(n1, n2, create_using=None):
 
 
 @py_random_state(3)
-@nx._dispatch(name="bipartite_configuration_model", graphs=None)
+@nx._dispatchable(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.
 
@@ -138,7 +138,7 @@ def configuration_model(aseq, bseq, create_using=None, seed=None):
     return G
 
 
-@nx._dispatch(name="bipartite_havel_hakimi_graph", graphs=None)
+@nx._dispatchable(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.
@@ -213,7 +213,7 @@ def havel_hakimi_graph(aseq, bseq, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(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.
@@ -287,7 +287,7 @@ def reverse_havel_hakimi_graph(aseq, bseq, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(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.
@@ -366,7 +366,7 @@ def alternating_havel_hakimi_graph(aseq, bseq, create_using=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(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.
@@ -438,7 +438,7 @@ def preferential_attachment_graph(aseq, p, create_using=None, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_graph(n, m, p, seed=None, directed=False):
     """Returns a bipartite random graph.
 
@@ -525,7 +525,7 @@ def random_graph(n, m, p, seed=None, directed=False):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def gnmk_random_graph(n, m, k, seed=None, directed=False):
     """Returns a random bipartite graph G_{n,m,k}.
 
diff --git a/networkx/algorithms/bipartite/matching.py b/networkx/algorithms/bipartite/matching.py
index 17d55614bcd..48149ab9e31 100644
--- a/networkx/algorithms/bipartite/matching.py
+++ b/networkx/algorithms/bipartite/matching.py
@@ -54,7 +54,7 @@
 INFINITY = float("inf")
 
 
-@nx._dispatch
+@nx._dispatchable
 def hopcroft_karp_matching(G, top_nodes=None):
     """Returns the maximum cardinality matching of the bipartite graph `G`.
 
@@ -181,7 +181,7 @@ def depth_first_search(v):
     return dict(itertools.chain(leftmatches.items(), rightmatches.items()))
 
 
-@nx._dispatch
+@nx._dispatchable
 def eppstein_matching(G, top_nodes=None):
     """Returns the maximum cardinality matching of the bipartite graph `G`.
 
@@ -420,7 +420,7 @@ def _connected_by_alternating_paths(G, matching, targets):
     }
 
 
-@nx._dispatch
+@nx._dispatchable
 def to_vertex_cover(G, matching, top_nodes=None):
     """Returns the minimum vertex cover corresponding to the given maximum
     matching of the bipartite graph `G`.
@@ -501,7 +501,7 @@ def to_vertex_cover(G, matching, top_nodes=None):
 maximum_matching = hopcroft_karp_matching
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def minimum_weight_full_matching(G, top_nodes=None, weight="weight"):
     r"""Returns a minimum weight full matching of the bipartite graph `G`.
 
diff --git a/networkx/algorithms/bipartite/matrix.py b/networkx/algorithms/bipartite/matrix.py
index e5679677574..8809e21b62e 100644
--- a/networkx/algorithms/bipartite/matrix.py
+++ b/networkx/algorithms/bipartite/matrix.py
@@ -11,7 +11,7 @@
 __all__ = ["biadjacency_matrix", "from_biadjacency_matrix"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def biadjacency_matrix(
     G, row_order, column_order=None, dtype=None, weight="weight", format="csr"
 ):
@@ -110,7 +110,7 @@ def biadjacency_matrix(
         raise nx.NetworkXError(f"Unknown sparse array format: {format}") from err
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(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.
diff --git a/networkx/algorithms/bipartite/projection.py b/networkx/algorithms/bipartite/projection.py
index 57f960e13b3..e0afe58a870 100644
--- a/networkx/algorithms/bipartite/projection.py
+++ b/networkx/algorithms/bipartite/projection.py
@@ -12,7 +12,7 @@
 ]
 
 
-@nx._dispatch(graphs="B", preserve_node_attrs=True, preserve_graph_attrs=True)
+@nx._dispatchable(graphs="B", preserve_node_attrs=True, preserve_graph_attrs=True)
 def projected_graph(B, nodes, multigraph=False):
     r"""Returns the projection of B onto one of its node sets.
 
@@ -117,7 +117,7 @@ def projected_graph(B, nodes, multigraph=False):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(graphs="B")
+@nx._dispatchable(graphs="B")
 def weighted_projected_graph(B, nodes, ratio=False):
     r"""Returns a weighted projection of B onto one of its node sets.
 
@@ -218,7 +218,7 @@ def weighted_projected_graph(B, nodes, ratio=False):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(graphs="B")
+@nx._dispatchable(graphs="B")
 def collaboration_weighted_projected_graph(B, nodes):
     r"""Newman's weighted projection of B onto one of its node sets.
 
@@ -313,7 +313,7 @@ def collaboration_weighted_projected_graph(B, nodes):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(graphs="B")
+@nx._dispatchable(graphs="B")
 def overlap_weighted_projected_graph(B, nodes, jaccard=True):
     r"""Overlap weighted projection of B onto one of its node sets.
 
@@ -413,7 +413,7 @@ def overlap_weighted_projected_graph(B, nodes, jaccard=True):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(graphs="B", preserve_all_attrs=True)
+@nx._dispatchable(graphs="B", preserve_all_attrs=True)
 def generic_weighted_projected_graph(B, nodes, weight_function=None):
     r"""Weighted projection of B with a user-specified weight function.
 
diff --git a/networkx/algorithms/bipartite/redundancy.py b/networkx/algorithms/bipartite/redundancy.py
index 04b3ae9ca75..7a44d212896 100644
--- a/networkx/algorithms/bipartite/redundancy.py
+++ b/networkx/algorithms/bipartite/redundancy.py
@@ -7,7 +7,7 @@
 __all__ = ["node_redundancy"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def node_redundancy(G, nodes=None):
     r"""Computes the node redundancy coefficients for the nodes in the bipartite
     graph `G`.
diff --git a/networkx/algorithms/bipartite/spectral.py b/networkx/algorithms/bipartite/spectral.py
index f4b414243ac..0ecd283775f 100644
--- a/networkx/algorithms/bipartite/spectral.py
+++ b/networkx/algorithms/bipartite/spectral.py
@@ -6,7 +6,7 @@
 __all__ = ["spectral_bipartivity"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def spectral_bipartivity(G, nodes=None, weight="weight"):
     """Returns the spectral bipartivity.
 
diff --git a/networkx/algorithms/boundary.py b/networkx/algorithms/boundary.py
index ea97cee6efb..fef9ba22369 100644
--- a/networkx/algorithms/boundary.py
+++ b/networkx/algorithms/boundary.py
@@ -15,7 +15,7 @@
 __all__ = ["edge_boundary", "node_boundary"]
 
 
-@nx._dispatch(edge_attrs={"data": "default"}, preserve_edge_attrs="data")
+@nx._dispatchable(edge_attrs={"data": "default"}, preserve_edge_attrs="data")
 def edge_boundary(G, nbunch1, nbunch2=None, data=False, keys=False, default=None):
     """Returns the edge boundary of `nbunch1`.
 
@@ -106,7 +106,7 @@ def edge_boundary(G, nbunch1, nbunch2=None, data=False, keys=False, default=None
     )
 
 
-@nx._dispatch
+@nx._dispatchable
 def node_boundary(G, nbunch1, nbunch2=None):
     """Returns the node boundary of `nbunch1`.
 
diff --git a/networkx/algorithms/bridges.py b/networkx/algorithms/bridges.py
index 106120e2fde..e076a256cb8 100644
--- a/networkx/algorithms/bridges.py
+++ b/networkx/algorithms/bridges.py
@@ -8,7 +8,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def bridges(G, root=None):
     """Generate all bridges in a graph.
 
@@ -81,7 +81,7 @@ def bridges(G, root=None):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def has_bridges(G, root=None):
     """Decide whether a graph has any bridges.
 
@@ -142,7 +142,7 @@ def has_bridges(G, root=None):
 
 @not_implemented_for("multigraph")
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def local_bridges(G, with_span=True, weight=None):
     """Iterate over local bridges of `G` optionally computing the span
 
diff --git a/networkx/algorithms/centrality/betweenness.py b/networkx/algorithms/centrality/betweenness.py
index b4b1f3963b0..4f44fb19ba0 100644
--- a/networkx/algorithms/centrality/betweenness.py
+++ b/networkx/algorithms/centrality/betweenness.py
@@ -12,7 +12,7 @@
 
 
 @py_random_state(5)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def betweenness_centrality(
     G, k=None, normalized=True, weight=None, endpoints=False, seed=None
 ):
@@ -154,7 +154,7 @@ def betweenness_centrality(
 
 
 @py_random_state(4)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def edge_betweenness_centrality(G, k=None, normalized=True, weight=None, seed=None):
     r"""Compute betweenness centrality for edges.
 
diff --git a/networkx/algorithms/centrality/betweenness_subset.py b/networkx/algorithms/centrality/betweenness_subset.py
index e6c1acdf4ff..7f9967e964c 100644
--- a/networkx/algorithms/centrality/betweenness_subset.py
+++ b/networkx/algorithms/centrality/betweenness_subset.py
@@ -16,7 +16,7 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def betweenness_centrality_subset(G, sources, targets, normalized=False, weight=None):
     r"""Compute betweenness centrality for a subset of nodes.
 
@@ -114,7 +114,7 @@ def betweenness_centrality_subset(G, sources, targets, normalized=False, weight=
     return b
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def edge_betweenness_centrality_subset(
     G, sources, targets, normalized=False, weight=None
 ):
diff --git a/networkx/algorithms/centrality/closeness.py b/networkx/algorithms/centrality/closeness.py
index 6a95ac14ef8..3527c468f33 100644
--- a/networkx/algorithms/centrality/closeness.py
+++ b/networkx/algorithms/centrality/closeness.py
@@ -10,7 +10,7 @@
 __all__ = ["closeness_centrality", "incremental_closeness_centrality"]
 
 
-@nx._dispatch(edge_attrs="distance")
+@nx._dispatchable(edge_attrs="distance")
 def closeness_centrality(G, u=None, distance=None, wf_improved=True):
     r"""Compute closeness centrality for nodes.
 
@@ -137,7 +137,7 @@ def closeness_centrality(G, u=None, distance=None, wf_improved=True):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def incremental_closeness_centrality(
     G, edge, prev_cc=None, insertion=True, wf_improved=True
 ):
diff --git a/networkx/algorithms/centrality/current_flow_betweenness.py b/networkx/algorithms/centrality/current_flow_betweenness.py
index ea1b2c8f2f4..9e68676b6a0 100644
--- a/networkx/algorithms/centrality/current_flow_betweenness.py
+++ b/networkx/algorithms/centrality/current_flow_betweenness.py
@@ -21,7 +21,7 @@
 
 @not_implemented_for("directed")
 @py_random_state(7)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def approximate_current_flow_betweenness_centrality(
     G,
     normalized=True,
@@ -144,7 +144,7 @@ def approximate_current_flow_betweenness_centrality(
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def current_flow_betweenness_centrality(
     G, normalized=True, weight=None, dtype=float, solver="full"
 ):
@@ -241,7 +241,7 @@ def current_flow_betweenness_centrality(
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def edge_current_flow_betweenness_centrality(
     G, normalized=True, weight=None, dtype=float, solver="full"
 ):
diff --git a/networkx/algorithms/centrality/current_flow_betweenness_subset.py b/networkx/algorithms/centrality/current_flow_betweenness_subset.py
index debfca27f55..38e744a835a 100644
--- a/networkx/algorithms/centrality/current_flow_betweenness_subset.py
+++ b/networkx/algorithms/centrality/current_flow_betweenness_subset.py
@@ -10,7 +10,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def current_flow_betweenness_centrality_subset(
     G, sources, targets, normalized=True, weight=None, dtype=float, solver="lu"
 ):
@@ -120,7 +120,7 @@ def current_flow_betweenness_centrality_subset(
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def edge_current_flow_betweenness_centrality_subset(
     G, sources, targets, normalized=True, weight=None, dtype=float, solver="lu"
 ):
diff --git a/networkx/algorithms/centrality/current_flow_closeness.py b/networkx/algorithms/centrality/current_flow_closeness.py
index daefbae902b..c4c8dd56c3e 100644
--- a/networkx/algorithms/centrality/current_flow_closeness.py
+++ b/networkx/algorithms/centrality/current_flow_closeness.py
@@ -11,7 +11,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def current_flow_closeness_centrality(G, weight=None, dtype=float, solver="lu"):
     """Compute current-flow closeness centrality for nodes.
 
diff --git a/networkx/algorithms/centrality/degree_alg.py b/networkx/algorithms/centrality/degree_alg.py
index 2631730dbc0..ea53f41ea3e 100644
--- a/networkx/algorithms/centrality/degree_alg.py
+++ b/networkx/algorithms/centrality/degree_alg.py
@@ -5,7 +5,7 @@
 __all__ = ["degree_centrality", "in_degree_centrality", "out_degree_centrality"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def degree_centrality(G):
     """Compute the degree centrality for nodes.
 
@@ -50,7 +50,7 @@ def degree_centrality(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def in_degree_centrality(G):
     """Compute the in-degree centrality for nodes.
 
@@ -100,7 +100,7 @@ def in_degree_centrality(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def out_degree_centrality(G):
     """Compute the out-degree centrality for nodes.
 
diff --git a/networkx/algorithms/centrality/dispersion.py b/networkx/algorithms/centrality/dispersion.py
index a551c387d88..a3fa68583a9 100644
--- a/networkx/algorithms/centrality/dispersion.py
+++ b/networkx/algorithms/centrality/dispersion.py
@@ -5,7 +5,7 @@
 __all__ = ["dispersion"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def dispersion(G, u=None, v=None, normalized=True, alpha=1.0, b=0.0, c=0.0):
     r"""Calculate dispersion between `u` and `v` in `G`.
 
diff --git a/networkx/algorithms/centrality/eigenvector.py b/networkx/algorithms/centrality/eigenvector.py
index 267e7b51027..f7fcbf78060 100644
--- a/networkx/algorithms/centrality/eigenvector.py
+++ b/networkx/algorithms/centrality/eigenvector.py
@@ -8,7 +8,7 @@
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def eigenvector_centrality(G, max_iter=100, tol=1.0e-6, nstart=None, weight=None):
     r"""Compute the eigenvector centrality for the graph G.
 
@@ -193,7 +193,7 @@ def eigenvector_centrality(G, max_iter=100, tol=1.0e-6, nstart=None, weight=None
     raise nx.PowerIterationFailedConvergence(max_iter)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def eigenvector_centrality_numpy(G, weight=None, max_iter=50, tol=0):
     r"""Compute the eigenvector centrality for the graph G.
 
diff --git a/networkx/algorithms/centrality/flow_matrix.py b/networkx/algorithms/centrality/flow_matrix.py
index e9cd7e26016..3874f6b2ffe 100644
--- a/networkx/algorithms/centrality/flow_matrix.py
+++ b/networkx/algorithms/centrality/flow_matrix.py
@@ -3,7 +3,7 @@
 import networkx as nx
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def flow_matrix_row(G, weight=None, dtype=float, solver="lu"):
     # Generate a row of the current-flow matrix
     import numpy as np
diff --git a/networkx/algorithms/centrality/group.py b/networkx/algorithms/centrality/group.py
index ff17d8f32ed..5819c357d03 100644
--- a/networkx/algorithms/centrality/group.py
+++ b/networkx/algorithms/centrality/group.py
@@ -19,7 +19,7 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def group_betweenness_centrality(G, C, normalized=True, weight=None, endpoints=False):
     r"""Compute the group betweenness centrality for a group of nodes.
 
@@ -236,7 +236,7 @@ def _group_preprocessing(G, set_v, weight):
     return PB, sigma, D
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def prominent_group(
     G, k, weight=None, C=None, endpoints=False, normalized=True, greedy=False
 ):
@@ -543,7 +543,7 @@ def _heuristic(k, root, DF_tree, D, nodes, greedy):
     return node_p, node_m, DF_tree
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def group_closeness_centrality(G, S, weight=None):
     r"""Compute the group closeness centrality for a group of nodes.
 
@@ -640,7 +640,7 @@ def group_closeness_centrality(G, S, weight=None):
     return closeness
 
 
-@nx._dispatch
+@nx._dispatchable
 def group_degree_centrality(G, S):
     """Compute the group degree centrality for a group of nodes.
 
@@ -692,7 +692,7 @@ def group_degree_centrality(G, S):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def group_in_degree_centrality(G, S):
     """Compute the group in-degree centrality for a group of nodes.
 
@@ -739,7 +739,7 @@ def group_in_degree_centrality(G, S):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def group_out_degree_centrality(G, S):
     """Compute the group out-degree centrality for a group of nodes.
 
diff --git a/networkx/algorithms/centrality/harmonic.py b/networkx/algorithms/centrality/harmonic.py
index 86b5020f96c..9cd9f7f0839 100644
--- a/networkx/algorithms/centrality/harmonic.py
+++ b/networkx/algorithms/centrality/harmonic.py
@@ -6,7 +6,7 @@
 __all__ = ["harmonic_centrality"]
 
 
-@nx._dispatch(edge_attrs="distance")
+@nx._dispatchable(edge_attrs="distance")
 def harmonic_centrality(G, nbunch=None, distance=None, sources=None):
     r"""Compute harmonic centrality for nodes.
 
diff --git a/networkx/algorithms/centrality/katz.py b/networkx/algorithms/centrality/katz.py
index 543fd879b97..527ec622fc4 100644
--- a/networkx/algorithms/centrality/katz.py
+++ b/networkx/algorithms/centrality/katz.py
@@ -8,7 +8,7 @@
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def katz_centrality(
     G,
     alpha=0.1,
@@ -194,7 +194,7 @@ def katz_centrality(
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def katz_centrality_numpy(G, alpha=0.1, beta=1.0, normalized=True, weight=None):
     r"""Compute the Katz centrality for the graph G.
 
diff --git a/networkx/algorithms/centrality/laplacian.py b/networkx/algorithms/centrality/laplacian.py
index d8a58e6b322..92ad463884b 100644
--- a/networkx/algorithms/centrality/laplacian.py
+++ b/networkx/algorithms/centrality/laplacian.py
@@ -6,7 +6,7 @@
 __all__ = ["laplacian_centrality"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def laplacian_centrality(
     G, normalized=True, nodelist=None, weight="weight", walk_type=None, alpha=0.95
 ):
diff --git a/networkx/algorithms/centrality/load.py b/networkx/algorithms/centrality/load.py
index 9a81cc43282..50bc6210b31 100644
--- a/networkx/algorithms/centrality/load.py
+++ b/networkx/algorithms/centrality/load.py
@@ -6,7 +6,7 @@
 __all__ = ["load_centrality", "edge_load_centrality"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def newman_betweenness_centrality(G, v=None, cutoff=None, normalized=True, weight=None):
     """Compute load centrality for nodes.
 
@@ -136,7 +136,7 @@ def _node_betweenness(G, source, cutoff=False, normalized=True, weight=None):
 load_centrality = newman_betweenness_centrality
 
 
-@nx._dispatch
+@nx._dispatchable
 def edge_load_centrality(G, cutoff=False):
     """Compute edge load.
 
diff --git a/networkx/algorithms/centrality/percolation.py b/networkx/algorithms/centrality/percolation.py
index cc5d5ce6d7d..0d4c87132b4 100644
--- a/networkx/algorithms/centrality/percolation.py
+++ b/networkx/algorithms/centrality/percolation.py
@@ -11,7 +11,7 @@
 __all__ = ["percolation_centrality"]
 
 
-@nx._dispatch(node_attrs="attribute", edge_attrs="weight")
+@nx._dispatchable(node_attrs="attribute", edge_attrs="weight")
 def percolation_centrality(G, attribute="percolation", states=None, weight=None):
     r"""Compute the percolation centrality for nodes.
 
diff --git a/networkx/algorithms/centrality/reaching.py b/networkx/algorithms/centrality/reaching.py
index e93c8e6d8cd..63ecc216eae 100644
--- a/networkx/algorithms/centrality/reaching.py
+++ b/networkx/algorithms/centrality/reaching.py
@@ -31,7 +31,7 @@ def _average_weight(G, path, weight=None):
     return total_weight / path_length
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def global_reaching_centrality(G, weight=None, normalized=True):
     """Returns the global reaching centrality of a directed graph.
 
@@ -119,7 +119,7 @@ def as_distance(u, v, d):
     return sum(max_lrc - c for c in lrc) / (len(G) - 1)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def local_reaching_centrality(G, v, paths=None, weight=None, normalized=True):
     """Returns the local reaching centrality of a node in a directed
     graph.
diff --git a/networkx/algorithms/centrality/second_order.py b/networkx/algorithms/centrality/second_order.py
index 4bdb1f52141..b08fe66b71f 100644
--- a/networkx/algorithms/centrality/second_order.py
+++ b/networkx/algorithms/centrality/second_order.py
@@ -39,7 +39,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def second_order_centrality(G, weight="weight"):
     """Compute the second order centrality for nodes of G.
 
diff --git a/networkx/algorithms/centrality/subgraph_alg.py b/networkx/algorithms/centrality/subgraph_alg.py
index c615b489201..3234e854b3c 100644
--- a/networkx/algorithms/centrality/subgraph_alg.py
+++ b/networkx/algorithms/centrality/subgraph_alg.py
@@ -14,7 +14,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def subgraph_centrality_exp(G):
     r"""Returns the subgraph centrality for each node of G.
 
@@ -98,7 +98,7 @@ def subgraph_centrality_exp(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def subgraph_centrality(G):
     r"""Returns subgraph centrality for each node in G.
 
@@ -189,7 +189,7 @@ def subgraph_centrality(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def communicability_betweenness_centrality(G):
     r"""Returns subgraph communicability for all pairs of nodes in G.
 
@@ -291,7 +291,7 @@ def communicability_betweenness_centrality(G):
     return cbc
 
 
-@nx._dispatch
+@nx._dispatchable
 def estrada_index(G):
     r"""Returns the Estrada index of a the graph G.
 
diff --git a/networkx/algorithms/centrality/trophic.py b/networkx/algorithms/centrality/trophic.py
index cfc7ea4f206..d6dcca1526f 100644
--- a/networkx/algorithms/centrality/trophic.py
+++ b/networkx/algorithms/centrality/trophic.py
@@ -6,7 +6,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def trophic_levels(G, weight="weight"):
     r"""Compute the trophic levels of nodes.
 
@@ -82,7 +82,7 @@ def trophic_levels(G, weight="weight"):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def trophic_differences(G, weight="weight"):
     r"""Compute the trophic differences of the edges of a directed graph.
 
@@ -117,7 +117,7 @@ def trophic_differences(G, weight="weight"):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def trophic_incoherence_parameter(G, weight="weight", cannibalism=False):
     r"""Compute the trophic incoherence parameter of a graph.
 
diff --git a/networkx/algorithms/centrality/voterank_alg.py b/networkx/algorithms/centrality/voterank_alg.py
index ca6bd913479..063dfdd64b3 100644
--- a/networkx/algorithms/centrality/voterank_alg.py
+++ b/networkx/algorithms/centrality/voterank_alg.py
@@ -4,7 +4,7 @@
 __all__ = ["voterank"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def voterank(G, number_of_nodes=None):
     """Select a list of influential nodes in a graph using VoteRank algorithm
 
diff --git a/networkx/algorithms/chains.py b/networkx/algorithms/chains.py
index 289bc1c3dd4..ae342d9c866 100644
--- a/networkx/algorithms/chains.py
+++ b/networkx/algorithms/chains.py
@@ -8,7 +8,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def chain_decomposition(G, root=None):
     """Returns the chain decomposition of a graph.
 
diff --git a/networkx/algorithms/chordal.py b/networkx/algorithms/chordal.py
index 0793761027a..875bf24d14e 100644
--- a/networkx/algorithms/chordal.py
+++ b/networkx/algorithms/chordal.py
@@ -28,7 +28,7 @@ class NetworkXTreewidthBoundExceeded(nx.NetworkXException):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def is_chordal(G):
     """Checks whether G is a chordal graph.
 
@@ -88,7 +88,7 @@ def is_chordal(G):
     return len(_find_chordality_breaker(G)) == 0
 
 
-@nx._dispatch
+@nx._dispatchable
 def find_induced_nodes(G, s, t, treewidth_bound=sys.maxsize):
     """Returns the set of induced nodes in the path from s to t.
 
@@ -168,7 +168,7 @@ def find_induced_nodes(G, s, t, treewidth_bound=sys.maxsize):
     return induced_nodes
 
 
-@nx._dispatch
+@nx._dispatchable
 def chordal_graph_cliques(G):
     """Returns all maximal cliques of a chordal graph.
 
@@ -241,7 +241,7 @@ def chordal_graph_cliques(G):
             yield frozenset(clique_wanna_be)
 
 
-@nx._dispatch
+@nx._dispatchable
 def chordal_graph_treewidth(G):
     """Returns the treewidth of the chordal graph G.
 
@@ -369,7 +369,7 @@ def _find_chordality_breaker(G, s=None, treewidth_bound=sys.maxsize):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def complete_to_chordal_graph(G):
     """Return a copy of G completed to a chordal graph
 
diff --git a/networkx/algorithms/clique.py b/networkx/algorithms/clique.py
index 7fd7e81665a..cb7210854e0 100644
--- a/networkx/algorithms/clique.py
+++ b/networkx/algorithms/clique.py
@@ -26,7 +26,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def enumerate_all_cliques(G):
     """Returns all cliques in an undirected graph.
 
@@ -98,7 +98,7 @@ def enumerate_all_cliques(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def find_cliques(G, nodes=None):
     """Returns all maximal cliques in an undirected graph.
 
@@ -294,7 +294,7 @@ def find_cliques(G, nodes=None):
 
 
 # TODO Should this also be not implemented for directed graphs?
-@nx._dispatch
+@nx._dispatchable
 def find_cliques_recursive(G, nodes=None):
     """Returns all maximal cliques in a graph.
 
@@ -412,7 +412,7 @@ def expand(subg, cand):
     return expand(subg_init, cand_init)
 
 
-@nx._dispatch
+@nx._dispatchable
 def make_max_clique_graph(G, create_using=None):
     """Returns the maximal clique graph of the given graph.
 
@@ -459,7 +459,7 @@ def make_max_clique_graph(G, create_using=None):
     return B
 
 
-@nx._dispatch
+@nx._dispatchable
 def make_clique_bipartite(G, fpos=None, create_using=None, name=None):
     """Returns the bipartite clique graph corresponding to `G`.
 
@@ -508,7 +508,7 @@ def make_clique_bipartite(G, fpos=None, create_using=None, name=None):
     return B
 
 
-@nx._dispatch
+@nx._dispatchable
 def node_clique_number(G, nodes=None, cliques=None, separate_nodes=False):
     """Returns the size of the largest maximal clique containing each given node.
 
@@ -698,7 +698,7 @@ def find_max_weight_clique(self):
 
 
 @not_implemented_for("directed")
-@nx._dispatch(node_attrs="weight")
+@nx._dispatchable(node_attrs="weight")
 def max_weight_clique(G, weight="weight"):
     """Find a maximum weight clique in G.
 
diff --git a/networkx/algorithms/cluster.py b/networkx/algorithms/cluster.py
index 4297d5c2862..35c86daeb58 100644
--- a/networkx/algorithms/cluster.py
+++ b/networkx/algorithms/cluster.py
@@ -17,7 +17,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def triangles(G, nodes=None):
     """Compute the number of triangles.
 
@@ -247,7 +247,7 @@ def wt(u, v):
         yield (i, dtotal, dbidirectional, directed_triangles)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def average_clustering(G, nodes=None, weight=None, count_zeros=True):
     r"""Compute the average clustering coefficient for the graph G.
 
@@ -307,7 +307,7 @@ def average_clustering(G, nodes=None, weight=None, count_zeros=True):
     return sum(c) / len(c)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def clustering(G, nodes=None, weight=None):
     r"""Compute the clustering coefficient for nodes.
 
@@ -422,7 +422,7 @@ def clustering(G, nodes=None, weight=None):
     return clusterc
 
 
-@nx._dispatch
+@nx._dispatchable
 def transitivity(G):
     r"""Compute graph transitivity, the fraction of all possible triangles
     present in G.
@@ -461,7 +461,7 @@ def transitivity(G):
     return 0 if triangles == 0 else triangles / contri
 
 
-@nx._dispatch
+@nx._dispatchable
 def square_clustering(G, nodes=None):
     r"""Compute the squares clustering coefficient for nodes.
 
@@ -540,7 +540,7 @@ def square_clustering(G, nodes=None):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def generalized_degree(G, nodes=None):
     r"""Compute the generalized degree for nodes.
 
diff --git a/networkx/algorithms/coloring/equitable_coloring.py b/networkx/algorithms/coloring/equitable_coloring.py
index af1fb5a7e7c..659609664c1 100644
--- a/networkx/algorithms/coloring/equitable_coloring.py
+++ b/networkx/algorithms/coloring/equitable_coloring.py
@@ -9,14 +9,14 @@
 __all__ = ["equitable_color"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_coloring(G, coloring):
     """Determine if the coloring is a valid coloring for the graph G."""
     # Verify that the coloring is valid.
     return all(coloring[s] != coloring[d] for s, d in G.edges)
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_equitable(G, coloring, num_colors=None):
     """Determines if the coloring is valid and equitable for the graph G."""
 
@@ -112,7 +112,7 @@ def move_witnesses(src_color, dst_color, N, H, F, C, T_cal, L):
         X = Y
 
 
-@nx._dispatch
+@nx._dispatchable
 def pad_graph(G, num_colors):
     """Add a disconnected complete clique K_p such that the number of nodes in
     the graph becomes a multiple of `num_colors`.
@@ -386,7 +386,7 @@ def procedure_P(V_minus, V_plus, N, H, F, C, L, excluded_colors=None):
                 break
 
 
-@nx._dispatch
+@nx._dispatchable
 def equitable_color(G, num_colors):
     """Provides an equitable coloring for nodes of `G`.
 
diff --git a/networkx/algorithms/coloring/greedy_coloring.py b/networkx/algorithms/coloring/greedy_coloring.py
index efc70f30eb8..661f14e0149 100644
--- a/networkx/algorithms/coloring/greedy_coloring.py
+++ b/networkx/algorithms/coloring/greedy_coloring.py
@@ -20,7 +20,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def strategy_largest_first(G, colors):
     """Returns a list of the nodes of ``G`` in decreasing order by
     degree.
@@ -32,7 +32,7 @@ def strategy_largest_first(G, colors):
 
 
 @py_random_state(2)
-@nx._dispatch
+@nx._dispatchable
 def strategy_random_sequential(G, colors, seed=None):
     """Returns a random permutation of the nodes of ``G`` as a list.
 
@@ -47,7 +47,7 @@ def strategy_random_sequential(G, colors, seed=None):
     return nodes
 
 
-@nx._dispatch
+@nx._dispatchable
 def strategy_smallest_last(G, colors):
     """Returns a deque of the nodes of ``G``, "smallest" last.
 
@@ -121,7 +121,7 @@ def _maximal_independent_set(G):
     return result
 
 
-@nx._dispatch
+@nx._dispatchable
 def strategy_independent_set(G, colors):
     """Uses a greedy independent set removal strategy to determine the
     colors.
@@ -146,7 +146,7 @@ def strategy_independent_set(G, colors):
         yield from nodes
 
 
-@nx._dispatch
+@nx._dispatchable
 def strategy_connected_sequential_bfs(G, colors):
     """Returns an iterable over nodes in ``G`` in the order given by a
     breadth-first traversal.
@@ -160,7 +160,7 @@ def strategy_connected_sequential_bfs(G, colors):
     return strategy_connected_sequential(G, colors, "bfs")
 
 
-@nx._dispatch
+@nx._dispatchable
 def strategy_connected_sequential_dfs(G, colors):
     """Returns an iterable over nodes in ``G`` in the order given by a
     depth-first traversal.
@@ -174,7 +174,7 @@ def strategy_connected_sequential_dfs(G, colors):
     return strategy_connected_sequential(G, colors, "dfs")
 
 
-@nx._dispatch
+@nx._dispatchable
 def strategy_connected_sequential(G, colors, traversal="bfs"):
     """Returns an iterable over nodes in ``G`` in the order given by a
     breadth-first or depth-first traversal.
@@ -207,7 +207,7 @@ def strategy_connected_sequential(G, colors, traversal="bfs"):
             yield end
 
 
-@nx._dispatch
+@nx._dispatchable
 def strategy_saturation_largest_first(G, colors):
     """Iterates over all the nodes of ``G`` in "saturation order" (also
     known as "DSATUR").
@@ -269,7 +269,7 @@ def strategy_saturation_largest_first(G, colors):
 }
 
 
-@nx._dispatch
+@nx._dispatchable
 def greedy_color(G, strategy="largest_first", interchange=False):
     """Color a graph using various strategies of greedy graph coloring.
 
diff --git a/networkx/algorithms/communicability_alg.py b/networkx/algorithms/communicability_alg.py
index c9144a7b84f..07316dc3ae2 100644
--- a/networkx/algorithms/communicability_alg.py
+++ b/networkx/algorithms/communicability_alg.py
@@ -9,7 +9,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def communicability(G):
     r"""Returns communicability between all pairs of nodes in G.
 
@@ -91,7 +91,7 @@ def communicability(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def communicability_exp(G):
     r"""Returns communicability between all pairs of nodes in G.
 
diff --git a/networkx/algorithms/community/asyn_fluid.py b/networkx/algorithms/community/asyn_fluid.py
index 490bb046e7a..fea72c1bfdb 100644
--- a/networkx/algorithms/community/asyn_fluid.py
+++ b/networkx/algorithms/community/asyn_fluid.py
@@ -13,7 +13,7 @@
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def asyn_fluidc(G, k, max_iter=100, seed=None):
     """Returns communities in `G` as detected by Fluid Communities algorithm.
 
diff --git a/networkx/algorithms/community/centrality.py b/networkx/algorithms/community/centrality.py
index efdc98460e4..43281701d2b 100644
--- a/networkx/algorithms/community/centrality.py
+++ b/networkx/algorithms/community/centrality.py
@@ -5,7 +5,7 @@
 __all__ = ["girvan_newman"]
 
 
-@nx._dispatch(preserve_edge_attrs="most_valuable_edge")
+@nx._dispatchable(preserve_edge_attrs="most_valuable_edge")
 def girvan_newman(G, most_valuable_edge=None):
     """Finds communities in a graph using the Girvan–Newman method.
 
diff --git a/networkx/algorithms/community/community_utils.py b/networkx/algorithms/community/community_utils.py
index 5e4727eec42..b57cd9881cb 100644
--- a/networkx/algorithms/community/community_utils.py
+++ b/networkx/algorithms/community/community_utils.py
@@ -4,7 +4,7 @@
 __all__ = ["is_partition"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_partition(G, communities):
     """Returns *True* if `communities` is a partition of the nodes of `G`.
 
diff --git a/networkx/algorithms/community/kclique.py b/networkx/algorithms/community/kclique.py
index 60433669cee..c7249104204 100644
--- a/networkx/algorithms/community/kclique.py
+++ b/networkx/algorithms/community/kclique.py
@@ -5,7 +5,7 @@
 __all__ = ["k_clique_communities"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def k_clique_communities(G, k, cliques=None):
     """Find k-clique communities in graph using the percolation method.
 
diff --git a/networkx/algorithms/community/kernighan_lin.py b/networkx/algorithms/community/kernighan_lin.py
index a18c7779b5b..f6397d82be6 100644
--- a/networkx/algorithms/community/kernighan_lin.py
+++ b/networkx/algorithms/community/kernighan_lin.py
@@ -42,7 +42,7 @@ def _update_costs(costs_x, x):
 
 @not_implemented_for("directed")
 @py_random_state(4)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def kernighan_lin_bisection(G, partition=None, max_iter=10, weight="weight", seed=None):
     """Partition a graph into two blocks using the Kernighan–Lin
     algorithm.
diff --git a/networkx/algorithms/community/label_propagation.py b/networkx/algorithms/community/label_propagation.py
index 307dfbe3a42..8690855766b 100644
--- a/networkx/algorithms/community/label_propagation.py
+++ b/networkx/algorithms/community/label_propagation.py
@@ -14,7 +14,7 @@
 
 
 @py_random_state("seed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def fast_label_propagation_communities(G, *, weight=None, seed=None):
     """Returns communities in `G` as detected by fast label propagation.
 
@@ -137,7 +137,7 @@ def _fast_label_count(G, comms, node, weight=None):
 
 
 @py_random_state(2)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def asyn_lpa_communities(G, weight=None, seed=None):
     """Returns communities in `G` as detected by asynchronous label
     propagation.
@@ -233,7 +233,7 @@ def asyn_lpa_communities(G, weight=None, seed=None):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def label_propagation_communities(G):
     """Generates community sets determined by label propagation
 
diff --git a/networkx/algorithms/community/louvain.py b/networkx/algorithms/community/louvain.py
index 6aa783d3152..0c880532b9d 100644
--- a/networkx/algorithms/community/louvain.py
+++ b/networkx/algorithms/community/louvain.py
@@ -11,7 +11,7 @@
 
 
 @py_random_state("seed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def louvain_communities(
     G, weight="weight", resolution=1, threshold=0.0000001, seed=None
 ):
@@ -121,7 +121,7 @@ def louvain_communities(
 
 
 @py_random_state("seed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def louvain_partitions(
     G, weight="weight", resolution=1, threshold=0.0000001, seed=None
 ):
diff --git a/networkx/algorithms/community/lukes.py b/networkx/algorithms/community/lukes.py
index 600a4db63d6..389fb51ca63 100644
--- a/networkx/algorithms/community/lukes.py
+++ b/networkx/algorithms/community/lukes.py
@@ -25,7 +25,7 @@ def _split_n_from(n, min_size_of_first_part):
         yield p1, n - p1
 
 
-@nx._dispatch(node_attrs="node_weight", edge_attrs="edge_weight")
+@nx._dispatchable(node_attrs="node_weight", edge_attrs="edge_weight")
 def lukes_partitioning(G, max_size, node_weight=None, edge_weight=None):
     """Optimal partitioning of a weighted tree using the Lukes algorithm.
 
diff --git a/networkx/algorithms/community/modularity_max.py b/networkx/algorithms/community/modularity_max.py
index d76116f7b2b..f465e01c6b2 100644
--- a/networkx/algorithms/community/modularity_max.py
+++ b/networkx/algorithms/community/modularity_max.py
@@ -223,7 +223,7 @@ def _greedy_modularity_communities_generator(G, weight=None, resolution=1):
         yield communities.values()
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def greedy_modularity_communities(
     G,
     weight=None,
@@ -356,7 +356,7 @@ def greedy_modularity_communities(
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def naive_greedy_modularity_communities(G, resolution=1, weight=None):
     r"""Find communities in G using greedy modularity maximization.
 
diff --git a/networkx/algorithms/community/quality.py b/networkx/algorithms/community/quality.py
index ab86b09113a..f09a6d454af 100644
--- a/networkx/algorithms/community/quality.py
+++ b/networkx/algorithms/community/quality.py
@@ -58,7 +58,7 @@ def _require_partition(G, partition):
 require_partition = argmap(_require_partition, (0, 1))
 
 
-@nx._dispatch
+@nx._dispatchable
 def intra_community_edges(G, partition):
     """Returns the number of intra-community edges for a partition of `G`.
 
@@ -76,7 +76,7 @@ def intra_community_edges(G, partition):
     return sum(G.subgraph(block).size() for block in partition)
 
 
-@nx._dispatch
+@nx._dispatchable
 def inter_community_edges(G, partition):
     """Returns the number of inter-community edges for a partition of `G`.
     according to the given
@@ -108,7 +108,7 @@ def inter_community_edges(G, partition):
     return nx.quotient_graph(G, partition, create_using=MG).size()
 
 
-@nx._dispatch
+@nx._dispatchable
 def inter_community_non_edges(G, partition):
     """Returns the number of inter-community non-edges according to the
     given partition of the nodes of `G`.
@@ -141,7 +141,7 @@ def inter_community_non_edges(G, partition):
     return inter_community_edges(nx.complement(G), partition)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def modularity(G, communities, weight="weight", resolution=1):
     r"""Returns the modularity of the given partition of the graph.
 
@@ -256,7 +256,7 @@ def community_contribution(community):
 
 
 @require_partition
-@nx._dispatch
+@nx._dispatchable
 def partition_quality(G, partition):
     """Returns the coverage and performance of a partition of G.
 
diff --git a/networkx/algorithms/components/attracting.py b/networkx/algorithms/components/attracting.py
index 1cc2e15615c..305c696353b 100644
--- a/networkx/algorithms/components/attracting.py
+++ b/networkx/algorithms/components/attracting.py
@@ -10,7 +10,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def attracting_components(G):
     """Generates the attracting components in `G`.
 
@@ -54,7 +54,7 @@ def attracting_components(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def number_attracting_components(G):
     """Returns the number of attracting components in `G`.
 
@@ -83,7 +83,7 @@ def number_attracting_components(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_attracting_component(G):
     """Returns True if `G` consists of a single attracting component.
 
diff --git a/networkx/algorithms/components/biconnected.py b/networkx/algorithms/components/biconnected.py
index 632b2d598d7..0d2f06975f8 100644
--- a/networkx/algorithms/components/biconnected.py
+++ b/networkx/algorithms/components/biconnected.py
@@ -13,7 +13,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def is_biconnected(G):
     """Returns True if the graph is biconnected, False otherwise.
 
@@ -94,7 +94,7 @@ def is_biconnected(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def biconnected_component_edges(G):
     """Returns a generator of lists of edges, one list for each biconnected
     component of the input graph.
@@ -167,7 +167,7 @@ def biconnected_component_edges(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def biconnected_components(G):
     """Returns a generator of sets of nodes, one set for each biconnected
     component of the graph
@@ -260,7 +260,7 @@ def biconnected_components(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def articulation_points(G):
     """Yield the articulation points, or cut vertices, of a graph.
 
diff --git a/networkx/algorithms/components/connected.py b/networkx/algorithms/components/connected.py
index 8bc10980fe2..ad3e0155a7f 100644
--- a/networkx/algorithms/components/connected.py
+++ b/networkx/algorithms/components/connected.py
@@ -13,7 +13,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def connected_components(G):
     """Generate connected components.
 
@@ -69,7 +69,7 @@ def connected_components(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def number_connected_components(G):
     """Returns the number of connected components.
 
@@ -109,7 +109,7 @@ def number_connected_components(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def is_connected(G):
     """Returns True if the graph is connected, False otherwise.
 
@@ -155,7 +155,7 @@ def is_connected(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def node_connected_component(G, n):
     """Returns the set of nodes in the component of graph containing node n.
 
diff --git a/networkx/algorithms/components/semiconnected.py b/networkx/algorithms/components/semiconnected.py
index 24a89f34d44..13cfa988a0b 100644
--- a/networkx/algorithms/components/semiconnected.py
+++ b/networkx/algorithms/components/semiconnected.py
@@ -6,7 +6,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_semiconnected(G):
     r"""Returns True if the graph is semiconnected, False otherwise.
 
diff --git a/networkx/algorithms/components/strongly_connected.py b/networkx/algorithms/components/strongly_connected.py
index 5bf5b994766..97370425f17 100644
--- a/networkx/algorithms/components/strongly_connected.py
+++ b/networkx/algorithms/components/strongly_connected.py
@@ -13,7 +13,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def strongly_connected_components(G):
     """Generate nodes in strongly connected components of graph.
 
@@ -112,7 +112,7 @@ def strongly_connected_components(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def kosaraju_strongly_connected_components(G, source=None):
     """Generate nodes in strongly connected components of graph.
 
@@ -174,7 +174,7 @@ def kosaraju_strongly_connected_components(G, source=None):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def strongly_connected_components_recursive(G):
     """Generate nodes in strongly connected components of graph.
 
@@ -256,7 +256,7 @@ def strongly_connected_components_recursive(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def number_strongly_connected_components(G):
     """Returns number of strongly connected components in graph.
 
@@ -295,7 +295,7 @@ def number_strongly_connected_components(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_strongly_connected(G):
     """Test directed graph for strong connectivity.
 
@@ -347,7 +347,7 @@ def is_strongly_connected(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def condensation(G, scc=None):
     """Returns the condensation of G.
 
diff --git a/networkx/algorithms/components/tests/test_connected.py b/networkx/algorithms/components/tests/test_connected.py
index 4c9b8d28fd5..cd08640b387 100644
--- a/networkx/algorithms/components/tests/test_connected.py
+++ b/networkx/algorithms/components/tests/test_connected.py
@@ -61,7 +61,7 @@ def setup_class(cls):
         C = []
         cls.gc.append((G, C))
 
-    # This additionally tests the @nx._dispatch mechanism, treating
+    # This additionally tests the @nx._dispatchable mechanism, treating
     # nx.connected_components as if it were a re-implementation from another package
     @pytest.mark.parametrize("wrapper", [lambda x: x, dispatch_interface.convert])
     def test_connected_components(self, wrapper):
diff --git a/networkx/algorithms/components/weakly_connected.py b/networkx/algorithms/components/weakly_connected.py
index c8dc2350ef1..7437fad8242 100644
--- a/networkx/algorithms/components/weakly_connected.py
+++ b/networkx/algorithms/components/weakly_connected.py
@@ -10,7 +10,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def weakly_connected_components(G):
     """Generate weakly connected components of G.
 
@@ -66,7 +66,7 @@ def weakly_connected_components(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def number_weakly_connected_components(G):
     """Returns the number of weakly connected components in G.
 
@@ -106,7 +106,7 @@ def number_weakly_connected_components(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_weakly_connected(G):
     """Test directed graph for weak connectivity.
 
diff --git a/networkx/algorithms/connectivity/connectivity.py b/networkx/algorithms/connectivity/connectivity.py
index cbb34152bba..06f035feb4d 100644
--- a/networkx/algorithms/connectivity/connectivity.py
+++ b/networkx/algorithms/connectivity/connectivity.py
@@ -31,7 +31,7 @@
 ]
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "auxiliary?": 4, "residual?": 5},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_graph_attrs={"auxiliary", "residual"},
@@ -214,7 +214,7 @@ def local_node_connectivity(
     return nx.maximum_flow_value(H, f"{mapping[s]}B", f"{mapping[t]}A", **kwargs)
 
 
-@nx._dispatch
+@nx._dispatchable
 def node_connectivity(G, s=None, t=None, flow_func=None):
     r"""Returns node connectivity for a graph or digraph G.
 
@@ -355,7 +355,7 @@ def neighbors(v):
     return K
 
 
-@nx._dispatch
+@nx._dispatchable
 def average_node_connectivity(G, flow_func=None):
     r"""Returns the average connectivity of a graph G.
 
@@ -424,7 +424,7 @@ def average_node_connectivity(G, flow_func=None):
     return num / den
 
 
-@nx._dispatch
+@nx._dispatchable
 def all_pairs_node_connectivity(G, nbunch=None, flow_func=None):
     """Compute node connectivity between all pairs of nodes of G.
 
@@ -492,7 +492,7 @@ def all_pairs_node_connectivity(G, nbunch=None, flow_func=None):
     return all_pairs
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "auxiliary?": 4, "residual?": 5},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_graph_attrs={"residual"},
@@ -658,7 +658,7 @@ def local_edge_connectivity(
     return nx.maximum_flow_value(H, s, t, **kwargs)
 
 
-@nx._dispatch
+@nx._dispatchable
 def edge_connectivity(G, s=None, t=None, flow_func=None, cutoff=None):
     r"""Returns the edge connectivity of the graph or digraph G.
 
diff --git a/networkx/algorithms/connectivity/cuts.py b/networkx/algorithms/connectivity/cuts.py
index d5883ba8f8e..e51c6843eb3 100644
--- a/networkx/algorithms/connectivity/cuts.py
+++ b/networkx/algorithms/connectivity/cuts.py
@@ -21,7 +21,7 @@
 ]
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "auxiliary?": 4, "residual?": 5},
     preserve_edge_attrs={
         "auxiliary": {"capacity": float("inf")},
@@ -161,7 +161,7 @@ def minimum_st_edge_cut(G, s, t, flow_func=None, auxiliary=None, residual=None):
     return cutset
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "auxiliary?": 4, "residual?": 5},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_node_attrs={"auxiliary": {"id": None}},
@@ -305,7 +305,7 @@ def minimum_st_node_cut(G, s, t, flow_func=None, auxiliary=None, residual=None):
     return node_cut - {s, t}
 
 
-@nx._dispatch
+@nx._dispatchable
 def minimum_node_cut(G, s=None, t=None, flow_func=None):
     r"""Returns a set of nodes of minimum cardinality that disconnects G.
 
@@ -451,7 +451,7 @@ def neighbors(v):
     return min_cut
 
 
-@nx._dispatch
+@nx._dispatchable
 def minimum_edge_cut(G, s=None, t=None, flow_func=None):
     r"""Returns a set of edges of minimum cardinality that disconnects G.
 
diff --git a/networkx/algorithms/connectivity/disjoint_paths.py b/networkx/algorithms/connectivity/disjoint_paths.py
index 3fe450517d5..b80aa9c7fb4 100644
--- a/networkx/algorithms/connectivity/disjoint_paths.py
+++ b/networkx/algorithms/connectivity/disjoint_paths.py
@@ -19,7 +19,7 @@
 __all__ = ["edge_disjoint_paths", "node_disjoint_paths"]
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "auxiliary?": 5, "residual?": 6},
     preserve_edge_attrs={
         "auxiliary": {"capacity": float("inf")},
@@ -234,7 +234,7 @@ def edge_disjoint_paths(
             paths_found += 1
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "auxiliary?": 5, "residual?": 6},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_node_attrs={"auxiliary": {"id": None}},
diff --git a/networkx/algorithms/connectivity/edge_augmentation.py b/networkx/algorithms/connectivity/edge_augmentation.py
index c1215509e88..0e77a0bf683 100644
--- a/networkx/algorithms/connectivity/edge_augmentation.py
+++ b/networkx/algorithms/connectivity/edge_augmentation.py
@@ -24,7 +24,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def is_k_edge_connected(G, k):
     """Tests to see if a graph is k-edge-connected.
 
@@ -75,7 +75,7 @@ def is_k_edge_connected(G, k):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def is_locally_k_edge_connected(G, s, t, k):
     """Tests to see if an edge in a graph is locally k-edge-connected.
 
@@ -133,7 +133,7 @@ def is_locally_k_edge_connected(G, s, t, k):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def k_edge_augmentation(G, k, avail=None, weight=None, partial=False):
     """Finds set of edges to k-edge-connect G.
 
@@ -284,7 +284,7 @@ def k_edge_augmentation(G, k, avail=None, weight=None, partial=False):
             raise
 
 
-@nx._dispatch
+@nx._dispatchable
 def partial_k_edge_augmentation(G, k, avail, weight=None):
     """Finds augmentation that k-edge-connects as much of the graph as possible.
 
@@ -387,7 +387,7 @@ def _edges_between_disjoint(H, only1, only2):
 
 @not_implemented_for("multigraph")
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def one_edge_augmentation(G, avail=None, weight=None, partial=False):
     """Finds minimum weight set of edges to connect G.
 
@@ -442,7 +442,7 @@ def one_edge_augmentation(G, avail=None, weight=None, partial=False):
 
 @not_implemented_for("multigraph")
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def bridge_augmentation(G, avail=None, weight=None):
     """Finds the a set of edges that bridge connects G.
 
@@ -578,7 +578,7 @@ def _lightest_meta_edges(mapping, avail_uv, avail_w):
             yield MetaEdge((mu, mv), (u, v), w)
 
 
-@nx._dispatch
+@nx._dispatchable
 def unconstrained_one_edge_augmentation(G):
     """Finds the smallest set of edges to connect G.
 
@@ -621,7 +621,7 @@ def unconstrained_one_edge_augmentation(G):
         yield (inverse[mu][0], inverse[mv][0])
 
 
-@nx._dispatch
+@nx._dispatchable
 def weighted_one_edge_augmentation(G, avail, weight=None, partial=False):
     """Finds the minimum weight set of edges to connect G if one exists.
 
@@ -690,7 +690,7 @@ def weighted_one_edge_augmentation(G, avail, weight=None, partial=False):
             yield edge
 
 
-@nx._dispatch
+@nx._dispatchable
 def unconstrained_bridge_augmentation(G):
     """Finds an optimal 2-edge-augmentation of G using the fewest edges.
 
@@ -845,7 +845,7 @@ def unconstrained_bridge_augmentation(G):
                 break
 
 
-@nx._dispatch
+@nx._dispatchable
 def weighted_bridge_augmentation(G, avail, weight=None):
     """Finds an approximate min-weight 2-edge-augmentation of G.
 
@@ -1040,7 +1040,7 @@ def _minimum_rooted_branching(D, root):
     return A
 
 
-@nx._dispatch
+@nx._dispatchable
 def collapse(G, grouped_nodes):
     """Collapses each group of nodes into a single node.
 
@@ -1112,7 +1112,7 @@ def collapse(G, grouped_nodes):
     return C
 
 
-@nx._dispatch
+@nx._dispatchable
 def complement_edges(G):
     """Returns only the edges in the complement of G
 
@@ -1158,7 +1158,7 @@ def _compat_shuffle(rng, input):
 @not_implemented_for("multigraph")
 @not_implemented_for("directed")
 @py_random_state(4)
-@nx._dispatch
+@nx._dispatchable
 def greedy_k_edge_augmentation(G, k, avail=None, weight=None, seed=None):
     """Greedy algorithm for finding a k-edge-augmentation
 
diff --git a/networkx/algorithms/connectivity/edge_kcomponents.py b/networkx/algorithms/connectivity/edge_kcomponents.py
index e602c33aaee..d2ed1ac5c7d 100644
--- a/networkx/algorithms/connectivity/edge_kcomponents.py
+++ b/networkx/algorithms/connectivity/edge_kcomponents.py
@@ -23,7 +23,7 @@
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def k_edge_components(G, k):
     """Generates nodes in each maximal k-edge-connected component in G.
 
@@ -107,7 +107,7 @@ def k_edge_components(G, k):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def k_edge_subgraphs(G, k):
     """Generates nodes in each maximal k-edge-connected subgraph in G.
 
@@ -196,7 +196,7 @@ def _k_edge_subgraphs_nodes(G, k):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def bridge_components(G):
     """Finds all bridge-connected components G.
 
@@ -503,7 +503,7 @@ def _high_degree_components(G, k):
         yield from nx.connected_components(H)
 
 
-@nx._dispatch
+@nx._dispatchable
 def general_k_edge_subgraphs(G, k):
     """General algorithm to find all maximal k-edge-connected subgraphs in G.
 
diff --git a/networkx/algorithms/connectivity/kcomponents.py b/networkx/algorithms/connectivity/kcomponents.py
index 19a6e486b84..50d5c8f4190 100644
--- a/networkx/algorithms/connectivity/kcomponents.py
+++ b/networkx/algorithms/connectivity/kcomponents.py
@@ -17,7 +17,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def k_components(G, flow_func=None):
     r"""Returns the k-component structure of a graph G.
 
diff --git a/networkx/algorithms/connectivity/kcutsets.py b/networkx/algorithms/connectivity/kcutsets.py
index f2036faf1e1..53f8d3b8f6e 100644
--- a/networkx/algorithms/connectivity/kcutsets.py
+++ b/networkx/algorithms/connectivity/kcutsets.py
@@ -21,7 +21,7 @@
 __all__ = ["all_node_cuts"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def all_node_cuts(G, k=None, flow_func=None):
     r"""Returns all minimum k cutsets of an undirected graph G.
 
diff --git a/networkx/algorithms/connectivity/stoerwagner.py b/networkx/algorithms/connectivity/stoerwagner.py
index dc95877e221..cd9d5acaf17 100644
--- a/networkx/algorithms/connectivity/stoerwagner.py
+++ b/networkx/algorithms/connectivity/stoerwagner.py
@@ -12,7 +12,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def stoer_wagner(G, weight="weight", heap=BinaryHeap):
     r"""Returns the weighted minimum edge cut using the Stoer-Wagner algorithm.
 
diff --git a/networkx/algorithms/connectivity/utils.py b/networkx/algorithms/connectivity/utils.py
index bf6860a208f..cd3dadf61da 100644
--- a/networkx/algorithms/connectivity/utils.py
+++ b/networkx/algorithms/connectivity/utils.py
@@ -6,7 +6,7 @@
 __all__ = ["build_auxiliary_node_connectivity", "build_auxiliary_edge_connectivity"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def build_auxiliary_node_connectivity(G):
     r"""Creates a directed graph D from an undirected graph G to compute flow
     based node connectivity.
@@ -59,7 +59,7 @@ def build_auxiliary_node_connectivity(G):
     return H
 
 
-@nx._dispatch
+@nx._dispatchable
 def build_auxiliary_edge_connectivity(G):
     """Auxiliary digraph for computing flow based edge connectivity
 
diff --git a/networkx/algorithms/core.py b/networkx/algorithms/core.py
index 87835c299d5..7ab7598260c 100644
--- a/networkx/algorithms/core.py
+++ b/networkx/algorithms/core.py
@@ -42,7 +42,7 @@
 
 
 @nx.utils.not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def core_number(G):
     """Returns the core number for each node.
 
@@ -148,7 +148,7 @@ def _core_subgraph(G, k_filter, k=None, core=None):
     return G.subgraph(nodes).copy()
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def k_core(G, k=None, core_number=None):
     """Returns the k-core of G.
 
@@ -224,7 +224,7 @@ def k_filter(v, k, c):
     return _core_subgraph(G, k_filter, k, core_number)
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def k_shell(G, k=None, core_number=None):
     """Returns the k-shell of G.
 
@@ -306,7 +306,7 @@ def k_filter(v, k, c):
     return _core_subgraph(G, k_filter, k, core_number)
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def k_crust(G, k=None, core_number=None):
     """Returns the k-crust of G.
 
@@ -389,7 +389,7 @@ def k_crust(G, k=None, core_number=None):
     return G.subgraph(nodes).copy()
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def k_corona(G, k, core_number=None):
     """Returns the k-corona of G.
 
@@ -468,7 +468,7 @@ def func(v, k, c):
 
 @nx.utils.not_implemented_for("directed")
 @nx.utils.not_implemented_for("multigraph")
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def k_truss(G, k):
     """Returns the k-truss of `G`.
 
@@ -550,7 +550,7 @@ def k_truss(G, k):
 
 @nx.utils.not_implemented_for("multigraph")
 @nx.utils.not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def onion_layers(G):
     """Returns the layer of each vertex in an onion decomposition of the graph.
 
diff --git a/networkx/algorithms/covering.py b/networkx/algorithms/covering.py
index b31521f4297..bed482bc4b3 100644
--- a/networkx/algorithms/covering.py
+++ b/networkx/algorithms/covering.py
@@ -11,7 +11,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def min_edge_cover(G, matching_algorithm=None):
     """Returns the min cardinality edge cover of the graph as a set of edges.
 
@@ -106,7 +106,7 @@ def min_edge_cover(G, matching_algorithm=None):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def is_edge_cover(G, cover):
     """Decides whether a set of edges is a valid edge cover of the graph.
 
diff --git a/networkx/algorithms/cuts.py b/networkx/algorithms/cuts.py
index ce455eb47c8..d7d54e7bb0d 100644
--- a/networkx/algorithms/cuts.py
+++ b/networkx/algorithms/cuts.py
@@ -21,7 +21,7 @@
 # TODO STILL NEED TO UPDATE ALL THE DOCUMENTATION!
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def cut_size(G, S, T=None, weight=None):
     """Returns the size of the cut between two sets of nodes.
 
@@ -84,7 +84,7 @@ def cut_size(G, S, T=None, weight=None):
     return sum(weight for u, v, weight in edges)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def volume(G, S, weight=None):
     """Returns the volume of a set of nodes.
 
@@ -127,7 +127,7 @@ def volume(G, S, weight=None):
     return sum(d for v, d in degree(S, weight=weight))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def normalized_cut_size(G, S, T=None, weight=None):
     """Returns the normalized size of the cut between two sets of nodes.
 
@@ -180,7 +180,7 @@ def normalized_cut_size(G, S, T=None, weight=None):
     return num_cut_edges * ((1 / volume_S) + (1 / volume_T))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def conductance(G, S, T=None, weight=None):
     """Returns the conductance of two sets of nodes.
 
@@ -228,7 +228,7 @@ def conductance(G, S, T=None, weight=None):
     return num_cut_edges / min(volume_S, volume_T)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def edge_expansion(G, S, T=None, weight=None):
     """Returns the edge expansion between two node sets.
 
@@ -275,7 +275,7 @@ def edge_expansion(G, S, T=None, weight=None):
     return num_cut_edges / min(len(S), len(T))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def mixing_expansion(G, S, T=None, weight=None):
     """Returns the mixing expansion between two node sets.
 
@@ -323,7 +323,7 @@ def mixing_expansion(G, S, T=None, weight=None):
 
 # TODO What is the generalization to two arguments, S and T? Does the
 # denominator become `min(len(S), len(T))`?
-@nx._dispatch
+@nx._dispatchable
 def node_expansion(G, S):
     """Returns the node expansion of the set `S`.
 
@@ -363,7 +363,7 @@ def node_expansion(G, S):
 
 # TODO What is the generalization to two arguments, S and T? Does the
 # denominator become `min(len(S), len(T))`?
-@nx._dispatch
+@nx._dispatchable
 def boundary_expansion(G, S):
     """Returns the boundary expansion of the set `S`.
 
diff --git a/networkx/algorithms/cycles.py b/networkx/algorithms/cycles.py
index 5221ca15893..dd7d4513a71 100644
--- a/networkx/algorithms/cycles.py
+++ b/networkx/algorithms/cycles.py
@@ -24,7 +24,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def cycle_basis(G, root=None):
     """Returns a list of cycles which form a basis for cycles of G.
 
@@ -101,7 +101,7 @@ def cycle_basis(G, root=None):
     return cycles
 
 
-@nx._dispatch
+@nx._dispatchable
 def simple_cycles(G, length_bound=None):
     """Find simple cycles (elementary circuits) of a graph.
 
@@ -474,7 +474,7 @@ def _bounded_cycle_search(G, path, length_bound):
                     B[w].add(v)
 
 
-@nx._dispatch
+@nx._dispatchable
 def chordless_cycles(G, length_bound=None):
     """Find simple chordless cycles of a graph.
 
@@ -763,7 +763,7 @@ def _chordless_cycle_search(F, B, path, length_bound):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def recursive_simple_cycles(G):
     """Find simple cycles (elementary circuits) of a directed graph.
 
@@ -873,7 +873,7 @@ def circuit(thisnode, startnode, component):
     return result
 
 
-@nx._dispatch
+@nx._dispatchable
 def find_cycle(G, source=None, orientation=None):
     """Returns a cycle found via depth-first traversal.
 
@@ -1035,7 +1035,7 @@ def tailhead(edge):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def minimum_cycle_basis(G, weight=None):
     """Returns a minimum weight cycle basis for G
 
@@ -1165,7 +1165,7 @@ def _min_cycle(G, orth, weight):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def girth(G):
     """Returns the girth of the graph.
 
diff --git a/networkx/algorithms/d_separation.py b/networkx/algorithms/d_separation.py
index dc1e105ee3a..a688eca4081 100644
--- a/networkx/algorithms/d_separation.py
+++ b/networkx/algorithms/d_separation.py
@@ -229,7 +229,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_d_separator(G, x, y, z):
     """Return whether node sets `x` and `y` are d-separated by `z`.
 
@@ -337,7 +337,7 @@ def is_d_separator(G, x, y, z):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def find_minimal_d_separator(G, x, y, *, included=None, restricted=None):
     """Returns a minimal d-separating set between `x` and `y` if possible
 
@@ -444,7 +444,7 @@ def find_minimal_d_separator(G, x, y, *, included=None, restricted=None):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_minimal_d_separator(G, x, y, z, *, included=None, restricted=None):
     """Determine if `z` is a minimal d-separator for `x` and `y`.
 
diff --git a/networkx/algorithms/dag.py b/networkx/algorithms/dag.py
index eb3a064e4b2..70cdd8d968d 100644
--- a/networkx/algorithms/dag.py
+++ b/networkx/algorithms/dag.py
@@ -36,7 +36,7 @@
 chaini = chain.from_iterable
 
 
-@nx._dispatch
+@nx._dispatchable
 def descendants(G, source):
     """Returns all nodes reachable from `source` in `G`.
 
@@ -73,7 +73,7 @@ def descendants(G, source):
     return {child for parent, child in nx.bfs_edges(G, source)}
 
 
-@nx._dispatch
+@nx._dispatchable
 def ancestors(G, source):
     """Returns all nodes having a path to `source` in `G`.
 
@@ -110,7 +110,7 @@ def ancestors(G, source):
     return {child for parent, child in nx.bfs_edges(G, source, reverse=True)}
 
 
-@nx._dispatch
+@nx._dispatchable
 def has_cycle(G):
     """Decides whether the directed graph has a cycle."""
     try:
@@ -122,7 +122,7 @@ def has_cycle(G):
         return False
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_directed_acyclic_graph(G):
     """Returns True if the graph `G` is a directed acyclic graph (DAG) or
     False if not.
@@ -163,7 +163,7 @@ def is_directed_acyclic_graph(G):
     return G.is_directed() and not has_cycle(G)
 
 
-@nx._dispatch
+@nx._dispatchable
 def topological_generations(G):
     """Stratifies a DAG into generations.
 
@@ -241,7 +241,7 @@ def topological_generations(G):
         )
 
 
-@nx._dispatch
+@nx._dispatchable
 def topological_sort(G):
     """Returns a generator of nodes in topologically sorted order.
 
@@ -310,7 +310,7 @@ def topological_sort(G):
         yield from generation
 
 
-@nx._dispatch
+@nx._dispatchable
 def lexicographical_topological_sort(G, key=None):
     """Generate the nodes in the unique lexicographical topological sort order.
 
@@ -453,7 +453,7 @@ def create_tuple(node):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def all_topological_sorts(G):
     """Returns a generator of _all_ topological sorts of the directed graph G.
 
@@ -572,7 +572,7 @@ def all_topological_sorts(G):
             break
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_aperiodic(G):
     """Returns True if `G` is aperiodic.
 
@@ -665,7 +665,7 @@ def is_aperiodic(G):
         return g == 1 and nx.is_aperiodic(G.subgraph(set(G) - set(levels)))
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def transitive_closure(G, reflexive=False):
     """Returns transitive closure of a graph
 
@@ -758,7 +758,7 @@ def transitive_closure(G, reflexive=False):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def transitive_closure_dag(G, topo_order=None):
     """Returns the transitive closure of a directed acyclic graph.
 
@@ -815,7 +815,7 @@ def transitive_closure_dag(G, topo_order=None):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def transitive_reduction(G):
     """Returns transitive reduction of a directed graph
 
@@ -888,7 +888,7 @@ def transitive_reduction(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def antichains(G, topo_order=None):
     """Generates antichains from a directed acyclic graph (DAG).
 
@@ -955,7 +955,7 @@ def antichains(G, topo_order=None):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(edge_attrs={"weight": "default_weight"})
+@nx._dispatchable(edge_attrs={"weight": "default_weight"})
 def dag_longest_path(G, weight="weight", default_weight=1, topo_order=None):
     """Returns the longest path in a directed acyclic graph (DAG).
 
@@ -1051,7 +1051,7 @@ def dag_longest_path(G, weight="weight", default_weight=1, topo_order=None):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(edge_attrs={"weight": "default_weight"})
+@nx._dispatchable(edge_attrs={"weight": "default_weight"})
 def dag_longest_path_length(G, weight="weight", default_weight=1):
     """Returns the longest path length in a DAG
 
@@ -1103,7 +1103,7 @@ def dag_longest_path_length(G, weight="weight", default_weight=1):
     return path_length
 
 
-@nx._dispatch
+@nx._dispatchable
 def root_to_leaf_paths(G):
     """Yields root-to-leaf paths in a directed acyclic graph.
 
@@ -1124,7 +1124,7 @@ def root_to_leaf_paths(G):
 
 @not_implemented_for("multigraph")
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def dag_to_branching(G):
     """Returns a branching representing all (overlapping) paths from
     root nodes to leaf nodes in the given directed acyclic graph.
@@ -1222,7 +1222,7 @@ def dag_to_branching(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def compute_v_structures(G):
     """Iterate through the graph to compute all v-structures.
 
diff --git a/networkx/algorithms/distance_measures.py b/networkx/algorithms/distance_measures.py
index 844e85f335b..423d9b6dee5 100644
--- a/networkx/algorithms/distance_measures.py
+++ b/networkx/algorithms/distance_measures.py
@@ -237,7 +237,7 @@ def _extrema_bounding(G, compute="diameter", weight=None):
     return None
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def eccentricity(G, v=None, sp=None, weight=None):
     """Returns the eccentricity of nodes in G.
 
@@ -326,7 +326,7 @@ def eccentricity(G, v=None, sp=None, weight=None):
     return e
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def diameter(G, e=None, usebounds=False, weight=None):
     """Returns the diameter of the graph G.
 
@@ -382,7 +382,7 @@ def diameter(G, e=None, usebounds=False, weight=None):
     return max(e.values())
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def periphery(G, e=None, usebounds=False, weight=None):
     """Returns the periphery of the graph G.
 
@@ -441,7 +441,7 @@ def periphery(G, e=None, usebounds=False, weight=None):
     return p
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def radius(G, e=None, usebounds=False, weight=None):
     """Returns the radius of the graph G.
 
@@ -494,7 +494,7 @@ def radius(G, e=None, usebounds=False, weight=None):
     return min(e.values())
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def center(G, e=None, usebounds=False, weight=None):
     """Returns the center of the graph G.
 
@@ -553,7 +553,7 @@ def center(G, e=None, usebounds=False, weight=None):
     return p
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def barycenter(G, weight=None, attr=None, sp=None):
     r"""Calculate barycenter of a connected graph, optionally with edge weights.
 
@@ -633,7 +633,7 @@ def barycenter(G, weight=None, attr=None, sp=None):
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def resistance_distance(G, nodeA=None, nodeB=None, weight=None, invert_weight=True):
     """Returns the resistance distance between pairs of nodes in graph G.
 
@@ -765,7 +765,7 @@ def resistance_distance(G, nodeA=None, nodeB=None, weight=None, invert_weight=Tr
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def effective_graph_resistance(G, weight=None, invert_weight=True):
     """Returns the Effective graph resistance of G.
 
@@ -853,7 +853,7 @@ def effective_graph_resistance(G, weight=None, invert_weight=True):
 
 
 @nx.utils.not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def kemeny_constant(G, *, weight=None):
     """Returns the Kemeny constant of the given graph.
 
diff --git a/networkx/algorithms/distance_regular.py b/networkx/algorithms/distance_regular.py
index 936fd5a2216..27b4d0216e4 100644
--- a/networkx/algorithms/distance_regular.py
+++ b/networkx/algorithms/distance_regular.py
@@ -17,7 +17,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_distance_regular(G):
     """Returns True if the graph is distance regular, False otherwise.
 
@@ -111,7 +111,7 @@ def global_parameters(b, c):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def intersection_array(G):
     """Returns the intersection array of a distance-regular graph.
 
@@ -184,7 +184,7 @@ def intersection_array(G):
 # TODO There is a definition for directed strongly regular graphs.
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def is_strongly_regular(G):
     """Returns True if and only if the given graph is strongly
     regular.
diff --git a/networkx/algorithms/dominance.py b/networkx/algorithms/dominance.py
index ffdbe7d2139..ab841fe21d5 100644
--- a/networkx/algorithms/dominance.py
+++ b/networkx/algorithms/dominance.py
@@ -11,7 +11,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def immediate_dominators(G, start):
     """Returns the immediate dominators of all nodes of a directed graph.
 
@@ -84,7 +84,7 @@ def intersect(u, v):
     return idom
 
 
-@nx._dispatch
+@nx._dispatchable
 def dominance_frontiers(G, start):
     """Returns the dominance frontiers of all nodes of a directed graph.
 
diff --git a/networkx/algorithms/dominating.py b/networkx/algorithms/dominating.py
index 80276bb5a1d..8e9a458f8e3 100644
--- a/networkx/algorithms/dominating.py
+++ b/networkx/algorithms/dominating.py
@@ -7,7 +7,7 @@
 __all__ = ["dominating_set", "is_dominating_set"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def dominating_set(G, start_with=None):
     r"""Finds a dominating set for the graph G.
 
@@ -65,7 +65,7 @@ def dominating_set(G, start_with=None):
     return dominating_set
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_dominating_set(G, nbunch):
     """Checks if `nbunch` is a dominating set for `G`.
 
diff --git a/networkx/algorithms/efficiency_measures.py b/networkx/algorithms/efficiency_measures.py
index 3beea38b013..2c99b011431 100644
--- a/networkx/algorithms/efficiency_measures.py
+++ b/networkx/algorithms/efficiency_measures.py
@@ -9,7 +9,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def efficiency(G, u, v):
     """Returns the efficiency of a pair of nodes in a graph.
 
@@ -60,7 +60,7 @@ def efficiency(G, u, v):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def global_efficiency(G):
     """Returns the average global efficiency of the graph.
 
@@ -121,7 +121,7 @@ def global_efficiency(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def local_efficiency(G):
     """Returns the average local efficiency of the graph.
 
diff --git a/networkx/algorithms/euler.py b/networkx/algorithms/euler.py
index 9d61b5e4130..54ab9bcff09 100644
--- a/networkx/algorithms/euler.py
+++ b/networkx/algorithms/euler.py
@@ -17,7 +17,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_eulerian(G):
     """Returns True if and only if `G` is Eulerian.
 
@@ -69,7 +69,7 @@ def is_eulerian(G):
     return all(d % 2 == 0 for v, d in G.degree()) and nx.is_connected(G)
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_semieulerian(G):
     """Return True iff `G` is semi-Eulerian.
 
@@ -154,7 +154,7 @@ def _multigraph_eulerian_circuit(G, source):
             G.remove_edge(current_vertex, next_vertex, next_key)
 
 
-@nx._dispatch
+@nx._dispatchable
 def eulerian_circuit(G, source=None, keys=False):
     """Returns an iterator over the edges of an Eulerian circuit in `G`.
 
@@ -235,7 +235,7 @@ def eulerian_circuit(G, source=None, keys=False):
         yield from _simplegraph_eulerian_circuit(G, source)
 
 
-@nx._dispatch
+@nx._dispatchable
 def has_eulerian_path(G, source=None):
     """Return True iff `G` has an Eulerian path.
 
@@ -330,7 +330,7 @@ def has_eulerian_path(G, source=None):
         return sum(d % 2 == 1 for v, d in G.degree()) == 2 and nx.is_connected(G)
 
 
-@nx._dispatch
+@nx._dispatchable
 def eulerian_path(G, source=None, keys=False):
     """Return an iterator over the edges of an Eulerian path in `G`.
 
@@ -386,7 +386,7 @@ def eulerian_path(G, source=None, keys=False):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def eulerize(G):
     """Transforms a graph into an Eulerian graph.
 
diff --git a/networkx/algorithms/flow/boykovkolmogorov.py b/networkx/algorithms/flow/boykovkolmogorov.py
index f571c98aebc..c75bbba69ca 100644
--- a/networkx/algorithms/flow/boykovkolmogorov.py
+++ b/networkx/algorithms/flow/boykovkolmogorov.py
@@ -10,7 +10,7 @@
 __all__ = ["boykov_kolmogorov"]
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "residual?": 4},
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
diff --git a/networkx/algorithms/flow/capacityscaling.py b/networkx/algorithms/flow/capacityscaling.py
index 2c0002d86c1..bf68565c548 100644
--- a/networkx/algorithms/flow/capacityscaling.py
+++ b/networkx/algorithms/flow/capacityscaling.py
@@ -149,7 +149,9 @@ def _build_flow_dict(G, R, capacity, weight):
     return flow_dict
 
 
-@nx._dispatch(node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0})
+@nx._dispatchable(
+    node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0}
+)
 def capacity_scaling(
     G, demand="demand", capacity="capacity", weight="weight", heap=BinaryHeap
 ):
diff --git a/networkx/algorithms/flow/dinitz_alg.py b/networkx/algorithms/flow/dinitz_alg.py
index 0348393d682..b40fd78351f 100644
--- a/networkx/algorithms/flow/dinitz_alg.py
+++ b/networkx/algorithms/flow/dinitz_alg.py
@@ -10,7 +10,7 @@
 __all__ = ["dinitz"]
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "residual?": 4},
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
diff --git a/networkx/algorithms/flow/edmondskarp.py b/networkx/algorithms/flow/edmondskarp.py
index 7c8440a4519..6fa76d7cabc 100644
--- a/networkx/algorithms/flow/edmondskarp.py
+++ b/networkx/algorithms/flow/edmondskarp.py
@@ -8,7 +8,7 @@
 __all__ = ["edmonds_karp"]
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs="R",
     preserve_edge_attrs={"R": {"capacity": float("inf"), "flow": 0}},
     preserve_graph_attrs=True,
@@ -122,7 +122,7 @@ def edmonds_karp_impl(G, s, t, capacity, residual, cutoff):
     return R
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "residual?": 4},
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
diff --git a/networkx/algorithms/flow/gomory_hu.py b/networkx/algorithms/flow/gomory_hu.py
index 0be27d56494..802c9621d80 100644
--- a/networkx/algorithms/flow/gomory_hu.py
+++ b/networkx/algorithms/flow/gomory_hu.py
@@ -13,7 +13,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(edge_attrs={"capacity": float("inf")})
 def gomory_hu_tree(G, capacity="capacity", flow_func=None):
     r"""Returns the Gomory-Hu tree of an undirected graph G.
 
diff --git a/networkx/algorithms/flow/maxflow.py b/networkx/algorithms/flow/maxflow.py
index 35f359ee3b0..f196fe31d46 100644
--- a/networkx/algorithms/flow/maxflow.py
+++ b/networkx/algorithms/flow/maxflow.py
@@ -16,7 +16,7 @@
 __all__ = ["maximum_flow", "maximum_flow_value", "minimum_cut", "minimum_cut_value"]
 
 
-@nx._dispatch(graphs="flowG", edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(graphs="flowG", edge_attrs={"capacity": float("inf")})
 def maximum_flow(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
     """Find a maximum single-commodity flow.
 
@@ -163,7 +163,7 @@ def maximum_flow(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
     return (R.graph["flow_value"], flow_dict)
 
 
-@nx._dispatch(graphs="flowG", edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(graphs="flowG", edge_attrs={"capacity": float("inf")})
 def maximum_flow_value(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
     """Find the value of maximum single-commodity flow.
 
@@ -303,7 +303,7 @@ def maximum_flow_value(flowG, _s, _t, capacity="capacity", flow_func=None, **kwa
     return R.graph["flow_value"]
 
 
-@nx._dispatch(graphs="flowG", edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(graphs="flowG", edge_attrs={"capacity": float("inf")})
 def minimum_cut(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
     """Compute the value and the node partition of a minimum (s, t)-cut.
 
@@ -467,7 +467,7 @@ def minimum_cut(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
     return (R.graph["flow_value"], partition)
 
 
-@nx._dispatch(graphs="flowG", edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(graphs="flowG", edge_attrs={"capacity": float("inf")})
 def minimum_cut_value(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
     """Compute the value of a minimum (s, t)-cut.
 
diff --git a/networkx/algorithms/flow/mincost.py b/networkx/algorithms/flow/mincost.py
index 7a6c3351190..2f9390d7a1c 100644
--- a/networkx/algorithms/flow/mincost.py
+++ b/networkx/algorithms/flow/mincost.py
@@ -7,7 +7,9 @@
 import networkx as nx
 
 
-@nx._dispatch(node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0})
+@nx._dispatchable(
+    node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0}
+)
 def min_cost_flow_cost(G, demand="demand", capacity="capacity", weight="weight"):
     r"""Find the cost of a minimum cost flow satisfying all demands in digraph G.
 
@@ -97,7 +99,9 @@ def min_cost_flow_cost(G, demand="demand", capacity="capacity", weight="weight")
     return nx.network_simplex(G, demand=demand, capacity=capacity, weight=weight)[0]
 
 
-@nx._dispatch(node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0})
+@nx._dispatchable(
+    node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0}
+)
 def min_cost_flow(G, demand="demand", capacity="capacity", weight="weight"):
     r"""Returns a minimum cost flow satisfying all demands in digraph G.
 
@@ -188,7 +192,7 @@ def min_cost_flow(G, demand="demand", capacity="capacity", weight="weight"):
     return nx.network_simplex(G, demand=demand, capacity=capacity, weight=weight)[1]
 
 
-@nx._dispatch(edge_attrs={"weight": 0})
+@nx._dispatchable(edge_attrs={"weight": 0})
 def cost_of_flow(G, flowDict, weight="weight"):
     """Compute the cost of the flow given by flowDict on graph G.
 
@@ -248,7 +252,7 @@ def cost_of_flow(G, flowDict, weight="weight"):
     return sum((flowDict[u][v] * d.get(weight, 0) for u, v, d in G.edges(data=True)))
 
 
-@nx._dispatch(edge_attrs={"capacity": float("inf"), "weight": 0})
+@nx._dispatchable(edge_attrs={"capacity": float("inf"), "weight": 0})
 def max_flow_min_cost(G, s, t, capacity="capacity", weight="weight"):
     """Returns a maximum (s, t)-flow of minimum cost.
 
diff --git a/networkx/algorithms/flow/networksimplex.py b/networkx/algorithms/flow/networksimplex.py
index 9fa3589a0c9..a9822d96880 100644
--- a/networkx/algorithms/flow/networksimplex.py
+++ b/networkx/algorithms/flow/networksimplex.py
@@ -326,7 +326,9 @@ def find_leaving_edge(self, Wn, We):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0})
+@nx._dispatchable(
+    node_attrs="demand", edge_attrs={"capacity": float("inf"), "weight": 0}
+)
 def network_simplex(G, demand="demand", capacity="capacity", weight="weight"):
     r"""Find a minimum cost flow satisfying all demands in digraph G.
 
diff --git a/networkx/algorithms/flow/preflowpush.py b/networkx/algorithms/flow/preflowpush.py
index 05b982ba1ff..50f6c8503a7 100644
--- a/networkx/algorithms/flow/preflowpush.py
+++ b/networkx/algorithms/flow/preflowpush.py
@@ -288,7 +288,7 @@ def global_relabel(from_sink):
     return R
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "residual?": 4},
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
diff --git a/networkx/algorithms/flow/shortestaugmentingpath.py b/networkx/algorithms/flow/shortestaugmentingpath.py
index d06a88b7bc8..ba50f7acb0c 100644
--- a/networkx/algorithms/flow/shortestaugmentingpath.py
+++ b/networkx/algorithms/flow/shortestaugmentingpath.py
@@ -163,7 +163,7 @@ def relabel(u):
     return R
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G": 0, "residual?": 4},
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
diff --git a/networkx/algorithms/flow/utils.py b/networkx/algorithms/flow/utils.py
index 349be4b302a..20ee78e0ae6 100644
--- a/networkx/algorithms/flow/utils.py
+++ b/networkx/algorithms/flow/utils.py
@@ -72,7 +72,7 @@ def clear_work(self):
         self._work = 0
 
 
-@nx._dispatch(edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(edge_attrs={"capacity": float("inf")})
 def build_residual_network(G, capacity):
     """Build a residual network and initialize a zero flow.
 
@@ -154,7 +154,7 @@ def build_residual_network(G, capacity):
     return R
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs="R",
     preserve_edge_attrs={"R": {"capacity": float("inf")}},
     preserve_graph_attrs=True,
@@ -176,7 +176,7 @@ def detect_unboundedness(R, s, t):
                 q.append(v)
 
 
-@nx._dispatch(graphs={"G": 0, "R": 1}, preserve_edge_attrs={"R": {"flow": None}})
+@nx._dispatchable(graphs={"G": 0, "R": 1}, preserve_edge_attrs={"R": {"flow": None}})
 def build_flow_dict(G, R):
     """Build a flow dictionary from a residual network."""
     flow_dict = {}
diff --git a/networkx/algorithms/graph_hashing.py b/networkx/algorithms/graph_hashing.py
index 0b69b08480c..bbe80671e85 100644
--- a/networkx/algorithms/graph_hashing.py
+++ b/networkx/algorithms/graph_hashing.py
@@ -37,7 +37,7 @@ def _neighborhood_aggregate(G, node, node_labels, edge_attr=None):
     return node_labels[node] + "".join(sorted(label_list))
 
 
-@nx._dispatch(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
+@nx._dispatchable(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
 def weisfeiler_lehman_graph_hash(
     G, edge_attr=None, node_attr=None, iterations=3, digest_size=16
 ):
@@ -160,7 +160,7 @@ def weisfeiler_lehman_step(G, labels, edge_attr=None):
     return _hash_label(str(tuple(subgraph_hash_counts)), digest_size)
 
 
-@nx._dispatch(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
+@nx._dispatchable(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
 def weisfeiler_lehman_subgraph_hashes(
     G, edge_attr=None, node_attr=None, iterations=3, digest_size=16
 ):
diff --git a/networkx/algorithms/graphical.py b/networkx/algorithms/graphical.py
index cb1664427fd..b2ce6c33a9a 100644
--- a/networkx/algorithms/graphical.py
+++ b/networkx/algorithms/graphical.py
@@ -14,7 +14,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_graphical(sequence, method="eg"):
     """Returns True if sequence is a valid degree sequence.
 
@@ -93,7 +93,7 @@ def _basic_graphical_tests(deg_sequence):
     return dmax, dmin, dsum, n, num_degs
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_valid_degree_sequence_havel_hakimi(deg_sequence):
     r"""Returns True if deg_sequence can be realized by a simple graph.
 
@@ -183,7 +183,7 @@ def is_valid_degree_sequence_havel_hakimi(deg_sequence):
     return True
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_valid_degree_sequence_erdos_gallai(deg_sequence):
     r"""Returns True if deg_sequence can be realized by a simple graph.
 
@@ -274,7 +274,7 @@ def is_valid_degree_sequence_erdos_gallai(deg_sequence):
     return True
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_multigraphical(sequence):
     """Returns True if some multigraph can realize the sequence.
 
@@ -325,7 +325,7 @@ def is_multigraphical(sequence):
     return True
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_pseudographical(sequence):
     """Returns True if some pseudograph can realize the sequence.
 
@@ -372,7 +372,7 @@ def is_pseudographical(sequence):
     return sum(deg_sequence) % 2 == 0 and min(deg_sequence) >= 0
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_digraphical(in_sequence, out_sequence):
     r"""Returns True if some directed graph can realize the in- and out-degree
     sequences.
diff --git a/networkx/algorithms/hierarchy.py b/networkx/algorithms/hierarchy.py
index 6dc63a741b5..4bb01cb4568 100644
--- a/networkx/algorithms/hierarchy.py
+++ b/networkx/algorithms/hierarchy.py
@@ -6,7 +6,7 @@
 __all__ = ["flow_hierarchy"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def flow_hierarchy(G, weight=None):
     """Returns the flow hierarchy of a directed network.
 
diff --git a/networkx/algorithms/hybrid.py b/networkx/algorithms/hybrid.py
index 347f5c2f199..c98774e002e 100644
--- a/networkx/algorithms/hybrid.py
+++ b/networkx/algorithms/hybrid.py
@@ -10,7 +10,7 @@
 __all__ = ["kl_connected_subgraph", "is_kl_connected"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def kl_connected_subgraph(G, k, l, low_memory=False, same_as_graph=False):
     """Returns the maximum locally `(k, l)`-connected subgraph of `G`.
 
@@ -115,7 +115,7 @@ def kl_connected_subgraph(G, k, l, low_memory=False, same_as_graph=False):
     return H
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_kl_connected(G, k, l, low_memory=False):
     """Returns True if and only if `G` is locally `(k, l)`-connected.
 
diff --git a/networkx/algorithms/isolate.py b/networkx/algorithms/isolate.py
index f9983282a63..23ac23875db 100644
--- a/networkx/algorithms/isolate.py
+++ b/networkx/algorithms/isolate.py
@@ -6,7 +6,7 @@
 __all__ = ["is_isolate", "isolates", "number_of_isolates"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_isolate(G, n):
     """Determines whether a node is an isolate.
 
@@ -39,7 +39,7 @@ def is_isolate(G, n):
     return G.degree(n) == 0
 
 
-@nx._dispatch
+@nx._dispatchable
 def isolates(G):
     """Iterator over isolates in the graph.
 
@@ -85,7 +85,7 @@ def isolates(G):
     return (n for n, d in G.degree() if d == 0)
 
 
-@nx._dispatch
+@nx._dispatchable
 def number_of_isolates(G):
     """Returns the number of isolates in the graph.
 
diff --git a/networkx/algorithms/isomorphism/isomorph.py b/networkx/algorithms/isomorphism/isomorph.py
index 6f562400a3b..00395b71cc1 100644
--- a/networkx/algorithms/isomorphism/isomorph.py
+++ b/networkx/algorithms/isomorphism/isomorph.py
@@ -12,7 +12,7 @@
 ]
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1})
 def could_be_isomorphic(G1, G2):
     """Returns False if graphs are definitely not isomorphic.
     True does NOT guarantee isomorphism.
@@ -60,7 +60,7 @@ def could_be_isomorphic(G1, G2):
 graph_could_be_isomorphic = could_be_isomorphic
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1})
 def fast_could_be_isomorphic(G1, G2):
     """Returns False if graphs are definitely not isomorphic.
 
@@ -101,7 +101,7 @@ def fast_could_be_isomorphic(G1, G2):
 fast_graph_could_be_isomorphic = fast_could_be_isomorphic
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1})
 def faster_could_be_isomorphic(G1, G2):
     """Returns False if graphs are definitely not isomorphic.
 
@@ -134,7 +134,7 @@ def faster_could_be_isomorphic(G1, G2):
 faster_graph_could_be_isomorphic = faster_could_be_isomorphic
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G1": 0, "G2": 1},
     preserve_edge_attrs="edge_match",
     preserve_node_attrs="node_match",
diff --git a/networkx/algorithms/isomorphism/tree_isomorphism.py b/networkx/algorithms/isomorphism/tree_isomorphism.py
index c0ef821c1e3..71a5890a116 100644
--- a/networkx/algorithms/isomorphism/tree_isomorphism.py
+++ b/networkx/algorithms/isomorphism/tree_isomorphism.py
@@ -24,7 +24,7 @@
 __all__ = ["rooted_tree_isomorphism", "tree_isomorphism"]
 
 
-@nx._dispatch(graphs={"t1": 0, "t2": 2})
+@nx._dispatchable(graphs={"t1": 0, "t2": 2})
 def root_trees(t1, root1, t2, root2):
     """Create a single digraph dT of free trees t1 and t2
     #   with roots root1 and root2 respectively
@@ -72,7 +72,7 @@ def root_trees(t1, root1, t2, root2):
 
 
 # figure out the level of each node, with 0 at root
-@nx._dispatch
+@nx._dispatchable
 def assign_levels(G, root):
     level = {}
     level[root] = 0
@@ -102,7 +102,7 @@ def generate_isomorphism(v, w, M, ordered_children):
         generate_isomorphism(x, y, M, ordered_children)
 
 
-@nx._dispatch(graphs={"t1": 0, "t2": 2})
+@nx._dispatchable(graphs={"t1": 0, "t2": 2})
 def rooted_tree_isomorphism(t1, root1, t2, root2):
     """
     Given two rooted trees `t1` and `t2`,
@@ -211,7 +211,7 @@ def rooted_tree_isomorphism(t1, root1, t2, root2):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(graphs={"t1": 0, "t2": 1})
+@nx._dispatchable(graphs={"t1": 0, "t2": 1})
 def tree_isomorphism(t1, t2):
     """
     Given two undirected (or free) trees `t1` and `t2`,
diff --git a/networkx/algorithms/isomorphism/vf2pp.py b/networkx/algorithms/isomorphism/vf2pp.py
index 8cc83eb8a53..589e06447cc 100644
--- a/networkx/algorithms/isomorphism/vf2pp.py
+++ b/networkx/algorithms/isomorphism/vf2pp.py
@@ -97,7 +97,7 @@
 )
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1}, node_attrs={"node_label": "default_label"})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1}, node_attrs={"node_label": "default_label"})
 def vf2pp_isomorphism(G1, G2, node_label=None, default_label=None):
     """Return an isomorphic mapping between `G1` and `G2` if it exists.
 
@@ -128,7 +128,7 @@ def vf2pp_isomorphism(G1, G2, node_label=None, default_label=None):
         return None
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1}, node_attrs={"node_label": "default_label"})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1}, node_attrs={"node_label": "default_label"})
 def vf2pp_is_isomorphic(G1, G2, node_label=None, default_label=None):
     """Examines whether G1 and G2 are isomorphic.
 
@@ -157,7 +157,7 @@ def vf2pp_is_isomorphic(G1, G2, node_label=None, default_label=None):
     return False
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1}, node_attrs={"node_label": "default_label"})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1}, node_attrs={"node_label": "default_label"})
 def vf2pp_all_isomorphisms(G1, G2, node_label=None, default_label=None):
     """Yields all the possible mappings between G1 and G2.
 
diff --git a/networkx/algorithms/link_analysis/hits_alg.py b/networkx/algorithms/link_analysis/hits_alg.py
index 8723c7d4932..e7b5141aa53 100644
--- a/networkx/algorithms/link_analysis/hits_alg.py
+++ b/networkx/algorithms/link_analysis/hits_alg.py
@@ -5,7 +5,7 @@
 __all__ = ["hits"]
 
 
-@nx._dispatch(preserve_edge_attrs={"G": {"weight": 1}})
+@nx._dispatchable(preserve_edge_attrs={"G": {"weight": 1}})
 def hits(G, max_iter=100, tol=1.0e-8, nstart=None, normalized=True):
     """Returns HITS hubs and authorities values for nodes.
 
diff --git a/networkx/algorithms/link_analysis/pagerank_alg.py b/networkx/algorithms/link_analysis/pagerank_alg.py
index 371dd60edd9..2a4af6e5f12 100644
--- a/networkx/algorithms/link_analysis/pagerank_alg.py
+++ b/networkx/algorithms/link_analysis/pagerank_alg.py
@@ -6,7 +6,7 @@
 __all__ = ["pagerank", "google_matrix"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def pagerank(
     G,
     alpha=0.85,
@@ -172,7 +172,7 @@ def _pagerank_python(
     raise nx.PowerIterationFailedConvergence(max_iter)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def google_matrix(
     G, alpha=0.85, personalization=None, nodelist=None, weight="weight", dangling=None
 ):
diff --git a/networkx/algorithms/link_analysis/tests/test_pagerank.py b/networkx/algorithms/link_analysis/tests/test_pagerank.py
index 6a30f0cd12c..db0f8c8d5bb 100644
--- a/networkx/algorithms/link_analysis/tests/test_pagerank.py
+++ b/networkx/algorithms/link_analysis/tests/test_pagerank.py
@@ -83,7 +83,7 @@ def test_numpy_pagerank(self):
         for n in G:
             assert p[n] == pytest.approx(G.pagerank[n], abs=1e-4)
 
-    # This additionally tests the @nx._dispatch mechanism, treating
+    # This additionally tests the @nx._dispatchable mechanism, treating
     # nx.google_matrix as if it were a re-implementation from another package
     @pytest.mark.parametrize("wrapper", [lambda x: x, dispatch_interface.convert])
     def test_google_matrix(self, wrapper):
diff --git a/networkx/algorithms/link_prediction.py b/networkx/algorithms/link_prediction.py
index 21e89fbf160..56f7bc5c1ba 100644
--- a/networkx/algorithms/link_prediction.py
+++ b/networkx/algorithms/link_prediction.py
@@ -48,7 +48,7 @@ def _apply_prediction(G, func, ebunch=None):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def resource_allocation_index(G, ebunch=None):
     r"""Compute the resource allocation index of all node pairs in ebunch.
 
@@ -111,7 +111,7 @@ def predict(u, v):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def jaccard_coefficient(G, ebunch=None):
     r"""Compute the Jaccard coefficient of all node pairs in ebunch.
 
@@ -176,7 +176,7 @@ def predict(u, v):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def adamic_adar_index(G, ebunch=None):
     r"""Compute the Adamic-Adar index of all node pairs in ebunch.
 
@@ -240,7 +240,7 @@ def predict(u, v):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def common_neighbor_centrality(G, ebunch=None, alpha=0.8):
     r"""Return the CCPA score for each pair of nodes.
 
@@ -349,7 +349,7 @@ def predict(u, v):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def preferential_attachment(G, ebunch=None):
     r"""Compute the preferential attachment score of all node pairs in ebunch.
 
@@ -411,7 +411,7 @@ def predict(u, v):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(node_attrs="community")
+@nx._dispatchable(node_attrs="community")
 def cn_soundarajan_hopcroft(G, ebunch=None, community="community"):
     r"""Count the number of common neighbors of all node pairs in ebunch
         using community information.
@@ -497,7 +497,7 @@ def predict(u, v):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(node_attrs="community")
+@nx._dispatchable(node_attrs="community")
 def ra_index_soundarajan_hopcroft(G, ebunch=None, community="community"):
     r"""Compute the resource allocation index of all node pairs in
     ebunch using community information.
@@ -584,7 +584,7 @@ def predict(u, v):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(node_attrs="community")
+@nx._dispatchable(node_attrs="community")
 def within_inter_cluster(G, ebunch=None, delta=0.001, community="community"):
     """Compute the ratio of within- and inter-cluster common neighbors
     of all node pairs in ebunch.
diff --git a/networkx/algorithms/lowest_common_ancestors.py b/networkx/algorithms/lowest_common_ancestors.py
index 3cad18bff39..f695ec208d3 100644
--- a/networkx/algorithms/lowest_common_ancestors.py
+++ b/networkx/algorithms/lowest_common_ancestors.py
@@ -14,7 +14,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def all_pairs_lowest_common_ancestor(G, pairs=None):
     """Return the lowest common ancestor of all pairs or the provided pairs
 
@@ -112,7 +112,7 @@ def generate_lca_from_pairs(G, pairs):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def lowest_common_ancestor(G, node1, node2, default=None):
     """Compute the lowest common ancestor of the given pair of nodes.
 
@@ -150,7 +150,7 @@ def lowest_common_ancestor(G, node1, node2, default=None):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def tree_all_pairs_lowest_common_ancestor(G, root=None, pairs=None):
     r"""Yield the lowest common ancestor for sets of pairs in a tree.
 
diff --git a/networkx/algorithms/matching.py b/networkx/algorithms/matching.py
index f44dc9e67cd..f346c2e052f 100644
--- a/networkx/algorithms/matching.py
+++ b/networkx/algorithms/matching.py
@@ -17,7 +17,7 @@
 
 @not_implemented_for("multigraph")
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def maximal_matching(G):
     r"""Find a maximal matching in the graph.
 
@@ -82,7 +82,7 @@ def matching_dict_to_set(matching):
     return edges
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_matching(G, matching):
     """Return True if ``matching`` is a valid matching of ``G``
 
@@ -143,7 +143,7 @@ def is_matching(G, matching):
     return True
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_maximal_matching(G, matching):
     """Return True if ``matching`` is a maximal matching of ``G``
 
@@ -205,7 +205,7 @@ def is_maximal_matching(G, matching):
     return True
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_perfect_matching(G, matching):
     """Return True if ``matching`` is a perfect matching for ``G``
 
@@ -259,7 +259,7 @@ def is_perfect_matching(G, matching):
 
 @not_implemented_for("multigraph")
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def min_weight_matching(G, weight="weight"):
     """Computing a minimum-weight maximal matching of G.
 
@@ -320,7 +320,7 @@ def min_weight_matching(G, weight="weight"):
 
 @not_implemented_for("multigraph")
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def max_weight_matching(G, maxcardinality=False, weight="weight"):
     """Compute a maximum-weighted matching of G.
 
diff --git a/networkx/algorithms/minors/contraction.py b/networkx/algorithms/minors/contraction.py
index 1b4da352296..08d1b3497e6 100644
--- a/networkx/algorithms/minors/contraction.py
+++ b/networkx/algorithms/minors/contraction.py
@@ -94,7 +94,7 @@ def equivalence_classes(iterable, relation):
     return {frozenset(block) for block in blocks}
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def quotient_graph(
     G,
     partition,
@@ -425,7 +425,7 @@ def edge_data(b, c):
     return H
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def contracted_nodes(G, u, v, self_loops=True, copy=True):
     """Returns the graph that results from contracting `u` and `v`.
 
@@ -560,7 +560,7 @@ def contracted_nodes(G, u, v, self_loops=True, copy=True):
 identified_nodes = contracted_nodes
 
 
-@nx._dispatch(preserve_edge_attrs=True)
+@nx._dispatchable(preserve_edge_attrs=True)
 def contracted_edge(G, edge, self_loops=True, copy=True):
     """Returns the graph that results from contracting the specified edge.
 
diff --git a/networkx/algorithms/mis.py b/networkx/algorithms/mis.py
index 00d101c5288..fc70514d9ea 100644
--- a/networkx/algorithms/mis.py
+++ b/networkx/algorithms/mis.py
@@ -10,7 +10,7 @@
 
 @not_implemented_for("directed")
 @py_random_state(2)
-@nx._dispatch
+@nx._dispatchable
 def maximal_independent_set(G, nodes=None, seed=None):
     """Returns a random maximal independent set guaranteed to contain
     a given set of nodes.
diff --git a/networkx/algorithms/moral.py b/networkx/algorithms/moral.py
index af187259251..8532f2b261f 100644
--- a/networkx/algorithms/moral.py
+++ b/networkx/algorithms/moral.py
@@ -9,7 +9,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def moral_graph(G):
     r"""Return the Moral Graph
 
diff --git a/networkx/algorithms/node_classification.py b/networkx/algorithms/node_classification.py
index c1b46545abb..42e7e6ba2ff 100644
--- a/networkx/algorithms/node_classification.py
+++ b/networkx/algorithms/node_classification.py
@@ -28,7 +28,7 @@
 
 
 @nx.utils.not_implemented_for("directed")
-@nx._dispatch(node_attrs="label_name")
+@nx._dispatchable(node_attrs="label_name")
 def harmonic_function(G, max_iter=30, label_name="label"):
     """Node classification by Harmonic function
 
@@ -105,7 +105,7 @@ def harmonic_function(G, max_iter=30, label_name="label"):
 
 
 @nx.utils.not_implemented_for("directed")
-@nx._dispatch(node_attrs="label_name")
+@nx._dispatchable(node_attrs="label_name")
 def local_and_global_consistency(G, alpha=0.99, max_iter=30, label_name="label"):
     """Node classification by Local and Global Consistency
 
diff --git a/networkx/algorithms/non_randomness.py b/networkx/algorithms/non_randomness.py
index 777cecbc969..88e8fd08e90 100644
--- a/networkx/algorithms/non_randomness.py
+++ b/networkx/algorithms/non_randomness.py
@@ -11,7 +11,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def non_randomness(G, k=None, weight="weight"):
     """Compute the non-randomness of graph G.
 
diff --git a/networkx/algorithms/operators/all.py b/networkx/algorithms/operators/all.py
index 1a9317b168b..4e0c2173b9c 100644
--- a/networkx/algorithms/operators/all.py
+++ b/networkx/algorithms/operators/all.py
@@ -7,7 +7,7 @@
 __all__ = ["union_all", "compose_all", "disjoint_union_all", "intersection_all"]
 
 
-@nx._dispatch(graphs="[graphs]", preserve_all_attrs=True)
+@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True)
 def union_all(graphs, rename=()):
     """Returns the union of all graphs.
 
@@ -110,7 +110,7 @@ def label(x):
     return R
 
 
-@nx._dispatch(graphs="[graphs]", preserve_all_attrs=True)
+@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True)
 def disjoint_union_all(graphs):
     """Returns the disjoint union of all graphs.
 
@@ -164,7 +164,7 @@ def yield_relabeled(graphs):
     return R
 
 
-@nx._dispatch(graphs="[graphs]", preserve_all_attrs=True)
+@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True)
 def compose_all(graphs):
     """Returns the composition of all graphs.
 
@@ -230,7 +230,7 @@ def compose_all(graphs):
     return R
 
 
-@nx._dispatch(graphs="[graphs]")
+@nx._dispatchable(graphs="[graphs]")
 def intersection_all(graphs):
     """Returns a new graph that contains only the nodes and the edges that exist in
     all graphs.
diff --git a/networkx/algorithms/operators/binary.py b/networkx/algorithms/operators/binary.py
index c36ea26c25c..9a9b5891e9a 100644
--- a/networkx/algorithms/operators/binary.py
+++ b/networkx/algorithms/operators/binary.py
@@ -15,7 +15,7 @@
 _G_H = {"G": 0, "H": 1}
 
 
-@nx._dispatch(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
 def union(G, H, rename=()):
     """Combine graphs G and H. The names of nodes must be unique.
 
@@ -71,7 +71,7 @@ def union(G, H, rename=()):
     return nx.union_all([G, H], rename)
 
 
-@nx._dispatch(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
 def disjoint_union(G, H):
     """Combine graphs G and H. The nodes are assumed to be unique (disjoint).
 
@@ -125,7 +125,7 @@ def disjoint_union(G, H):
     return nx.disjoint_union_all([G, H])
 
 
-@nx._dispatch(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H)
 def intersection(G, H):
     """Returns a new graph that contains only the nodes and the edges that exist in
     both G and H.
@@ -170,7 +170,7 @@ def intersection(G, H):
     return nx.intersection_all([G, H])
 
 
-@nx._dispatch(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H)
 def difference(G, H):
     """Returns a new graph that contains the edges that exist in G but not in H.
 
@@ -225,7 +225,7 @@ def difference(G, H):
     return R
 
 
-@nx._dispatch(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H)
 def symmetric_difference(G, H):
     """Returns new graph with edges that exist in either G or H but not both.
 
@@ -288,7 +288,7 @@ def symmetric_difference(G, H):
     return R
 
 
-@nx._dispatch(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
 def compose(G, H):
     """Compose graph G with H by combining nodes and edges into a single graph.
 
@@ -365,7 +365,7 @@ def compose(G, H):
     return nx.compose_all([G, H])
 
 
-@nx._dispatch(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
 def full_join(G, H, rename=(None, None)):
     """Returns the full join of graphs G and H.
 
diff --git a/networkx/algorithms/operators/product.py b/networkx/algorithms/operators/product.py
index e7da4fc73be..9a8063c91e2 100644
--- a/networkx/algorithms/operators/product.py
+++ b/networkx/algorithms/operators/product.py
@@ -123,7 +123,7 @@ def _init_product_graph(G, H):
     return GH
 
 
-@nx._dispatch(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
 def tensor_product(G, H):
     r"""Returns the tensor product of G and H.
 
@@ -179,7 +179,7 @@ def tensor_product(G, H):
     return GH
 
 
-@nx._dispatch(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
 def cartesian_product(G, H):
     r"""Returns the Cartesian product of G and H.
 
@@ -231,7 +231,7 @@ def cartesian_product(G, H):
     return GH
 
 
-@nx._dispatch(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
 def lexicographic_product(G, H):
     r"""Returns the lexicographic product of G and H.
 
@@ -284,7 +284,7 @@ def lexicographic_product(G, H):
     return GH
 
 
-@nx._dispatch(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
 def strong_product(G, H):
     r"""Returns the strong product of G and H.
 
@@ -342,7 +342,7 @@ def strong_product(G, H):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def power(G, k):
     """Returns the specified power of a graph.
 
@@ -431,7 +431,7 @@ def power(G, k):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H)
 def rooted_product(G, H, root):
     """Return the rooted product of graphs G and H rooted at root in H.
 
@@ -471,7 +471,7 @@ def rooted_product(G, H, root):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H)
 def corona_product(G, H):
     r"""Returns the Corona product of G and H.
 
diff --git a/networkx/algorithms/operators/tests/test_binary.py b/networkx/algorithms/operators/tests/test_binary.py
index 4ce6f9bf033..9693e6332f5 100644
--- a/networkx/algorithms/operators/tests/test_binary.py
+++ b/networkx/algorithms/operators/tests/test_binary.py
@@ -43,7 +43,7 @@ def test_intersection():
     assert sorted(I.edges()) == [(2, 3)]
 
     ##################
-    # Tests for @nx._dispatch mechanism with multiple graph arguments
+    # Tests for @nx._dispatchable mechanism with multiple graph arguments
     # nx.intersection is called as if it were a re-implementation
     # from another package.
     ###################
@@ -53,7 +53,7 @@ def test_intersection():
     assert set(I2.nodes()) == {1, 2, 3, 4}
     assert sorted(I2.edges()) == [(2, 3)]
     # Only test if not performing auto convert testing of backend implementations
-    if not nx.utils.backends._dispatch._automatic_backends:
+    if not nx.utils.backends._dispatchable._automatic_backends:
         with pytest.raises(TypeError):
             nx.intersection(G2, H)
         with pytest.raises(TypeError):
diff --git a/networkx/algorithms/operators/unary.py b/networkx/algorithms/operators/unary.py
index ce6d9be9057..42309ee9ff0 100644
--- a/networkx/algorithms/operators/unary.py
+++ b/networkx/algorithms/operators/unary.py
@@ -4,7 +4,7 @@
 __all__ = ["complement", "reverse"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def complement(G):
     """Returns the graph complement of G.
 
@@ -40,7 +40,7 @@ def complement(G):
     return R
 
 
-@nx._dispatch
+@nx._dispatchable
 def reverse(G, copy=True):
     """Returns the reverse directed graph of G.
 
diff --git a/networkx/algorithms/planarity.py b/networkx/algorithms/planarity.py
index 59206b412e0..db494481cd1 100644
--- a/networkx/algorithms/planarity.py
+++ b/networkx/algorithms/planarity.py
@@ -5,7 +5,7 @@
 __all__ = ["check_planarity", "is_planar", "PlanarEmbedding"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_planar(G):
     """Returns True if and only if `G` is planar.
 
@@ -38,7 +38,7 @@ def is_planar(G):
     return check_planarity(G, counterexample=False)[0]
 
 
-@nx._dispatch
+@nx._dispatchable
 def check_planarity(G, counterexample=False):
     """Check if a graph is planar and return a counterexample or an embedding.
 
@@ -114,7 +114,7 @@ def check_planarity(G, counterexample=False):
         return True, embedding
 
 
-@nx._dispatch
+@nx._dispatchable
 def check_planarity_recursive(G, counterexample=False):
     """Recursive version of :meth:`check_planarity`."""
     planarity_state = LRPlanarity(G)
@@ -130,7 +130,7 @@ def check_planarity_recursive(G, counterexample=False):
         return True, embedding
 
 
-@nx._dispatch
+@nx._dispatchable
 def get_counterexample(G):
     """Obtains a Kuratowski subgraph.
 
@@ -169,7 +169,7 @@ def get_counterexample(G):
     return subgraph
 
 
-@nx._dispatch
+@nx._dispatchable
 def get_counterexample_recursive(G):
     """Recursive version of :meth:`get_counterexample`."""
 
diff --git a/networkx/algorithms/polynomials.py b/networkx/algorithms/polynomials.py
index 57ecf0d09a9..217c7dbe37b 100644
--- a/networkx/algorithms/polynomials.py
+++ b/networkx/algorithms/polynomials.py
@@ -30,7 +30,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def tutte_polynomial(G):
     r"""Returns the Tutte polynomial of `G`
 
@@ -180,7 +180,7 @@ def tutte_polynomial(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def chromatic_polynomial(G):
     r"""Returns the chromatic polynomial of `G`
 
diff --git a/networkx/algorithms/reciprocity.py b/networkx/algorithms/reciprocity.py
index cb36ae9d551..25b0fa1ba9c 100644
--- a/networkx/algorithms/reciprocity.py
+++ b/networkx/algorithms/reciprocity.py
@@ -8,7 +8,7 @@
 
 
 @not_implemented_for("undirected", "multigraph")
-@nx._dispatch
+@nx._dispatchable
 def reciprocity(G, nodes=None):
     r"""Compute the reciprocity in a directed graph.
 
@@ -76,7 +76,7 @@ def _reciprocity_iter(G, nodes):
 
 
 @not_implemented_for("undirected", "multigraph")
-@nx._dispatch
+@nx._dispatchable
 def overall_reciprocity(G):
     """Compute the reciprocity for the whole graph.
 
diff --git a/networkx/algorithms/regular.py b/networkx/algorithms/regular.py
index 52b5ed6ee81..01027cd8677 100644
--- a/networkx/algorithms/regular.py
+++ b/networkx/algorithms/regular.py
@@ -5,7 +5,7 @@
 __all__ = ["is_regular", "is_k_regular", "k_factor"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_regular(G):
     """Determines whether the graph ``G`` is a regular graph.
 
@@ -44,7 +44,7 @@ def is_regular(G):
 
 
 @not_implemented_for("directed")
-@nx._dispatch
+@nx._dispatchable
 def is_k_regular(G, k):
     """Determines whether the graph ``G`` is a k-regular graph.
 
@@ -71,7 +71,7 @@ def is_k_regular(G, k):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(preserve_edge_attrs=True)
+@nx._dispatchable(preserve_edge_attrs=True)
 def k_factor(G, k, matching_weight="weight"):
     """Compute a k-factor of G
 
diff --git a/networkx/algorithms/richclub.py b/networkx/algorithms/richclub.py
index 6fe300fb538..f787f4254bf 100644
--- a/networkx/algorithms/richclub.py
+++ b/networkx/algorithms/richclub.py
@@ -10,7 +10,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def rich_club_coefficient(G, normalized=True, Q=100, seed=None):
     r"""Returns the rich-club coefficient of the graph `G`.
 
diff --git a/networkx/algorithms/shortest_paths/astar.py b/networkx/algorithms/shortest_paths/astar.py
index 64696353e40..1a36561fe80 100644
--- a/networkx/algorithms/shortest_paths/astar.py
+++ b/networkx/algorithms/shortest_paths/astar.py
@@ -9,7 +9,7 @@
 __all__ = ["astar_path", "astar_path_length"]
 
 
-@nx._dispatch(edge_attrs="weight", preserve_node_attrs="heuristic")
+@nx._dispatchable(edge_attrs="weight", preserve_node_attrs="heuristic")
 def astar_path(G, source, target, heuristic=None, weight="weight", *, cutoff=None):
     """Returns a list of nodes in a shortest path between source and target
     using the A* ("A-star") algorithm.
@@ -171,7 +171,7 @@ def heuristic(u, v):
     raise nx.NetworkXNoPath(f"Node {target} not reachable from {source}")
 
 
-@nx._dispatch(edge_attrs="weight", preserve_node_attrs="heuristic")
+@nx._dispatchable(edge_attrs="weight", preserve_node_attrs="heuristic")
 def astar_path_length(
     G, source, target, heuristic=None, weight="weight", *, cutoff=None
 ):
diff --git a/networkx/algorithms/shortest_paths/dense.py b/networkx/algorithms/shortest_paths/dense.py
index 08339b189dd..45fcac3249f 100644
--- a/networkx/algorithms/shortest_paths/dense.py
+++ b/networkx/algorithms/shortest_paths/dense.py
@@ -10,7 +10,7 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def floyd_warshall_numpy(G, nodelist=None, weight="weight"):
     """Find all-pairs shortest path lengths using Floyd's algorithm.
 
@@ -84,7 +84,7 @@ def floyd_warshall_numpy(G, nodelist=None, weight="weight"):
     return A
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def floyd_warshall_predecessor_and_distance(G, weight="weight"):
     """Find all-pairs shortest path lengths using Floyd's algorithm.
 
@@ -167,7 +167,7 @@ def floyd_warshall_predecessor_and_distance(G, weight="weight"):
     return dict(pred), dict(dist)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(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
@@ -211,7 +211,7 @@ def reconstruct_path(source, target, predecessors):
     return list(reversed(path))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def floyd_warshall(G, weight="weight"):
     """Find all-pairs shortest path lengths using Floyd's algorithm.
 
diff --git a/networkx/algorithms/shortest_paths/generic.py b/networkx/algorithms/shortest_paths/generic.py
index 1ed47aa7144..6d8d8c823e5 100644
--- a/networkx/algorithms/shortest_paths/generic.py
+++ b/networkx/algorithms/shortest_paths/generic.py
@@ -19,7 +19,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def has_path(G, source, target):
     """Returns *True* if *G* has a path from *source* to *target*.
 
@@ -40,7 +40,7 @@ def has_path(G, source, target):
     return True
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def shortest_path(G, source=None, target=None, weight=None, method="dijkstra"):
     """Compute shortest paths in the graph.
 
@@ -187,7 +187,7 @@ def shortest_path(G, source=None, target=None, weight=None, method="dijkstra"):
     return paths
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def shortest_path_length(G, source=None, target=None, weight=None, method="dijkstra"):
     """Compute shortest path lengths in the graph.
 
@@ -331,7 +331,7 @@ def shortest_path_length(G, source=None, target=None, weight=None, method="dijks
     return paths
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def average_shortest_path_length(G, weight=None, method=None):
     r"""Returns the average shortest path length.
 
@@ -448,7 +448,7 @@ def path_length(v):
     return s / (n * (n - 1))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def all_shortest_paths(G, source, target, weight=None, method="dijkstra"):
     """Compute all shortest simple paths in the graph.
 
@@ -526,7 +526,7 @@ def all_shortest_paths(G, source, target, weight=None, method="dijkstra"):
     return _build_paths_from_predecessors({source}, target, pred)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def single_source_all_shortest_paths(G, source, weight=None, method="dijkstra"):
     """Compute all shortest simple paths from the given source in the graph.
 
@@ -602,7 +602,7 @@ def single_source_all_shortest_paths(G, source, weight=None, method="dijkstra"):
             pass
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def all_pairs_all_shortest_paths(G, weight=None, method="dijkstra"):
     """Compute all shortest paths between all nodes.
 
diff --git a/networkx/algorithms/shortest_paths/unweighted.py b/networkx/algorithms/shortest_paths/unweighted.py
index bc329c55263..c7eea6fc625 100644
--- a/networkx/algorithms/shortest_paths/unweighted.py
+++ b/networkx/algorithms/shortest_paths/unweighted.py
@@ -17,7 +17,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def single_source_shortest_path_length(G, source, cutoff=None):
     """Compute the shortest path lengths from source to all reachable nodes.
 
@@ -95,7 +95,7 @@ def _single_shortest_path_length(adj, firstlevel, cutoff):
                 return
 
 
-@nx._dispatch
+@nx._dispatchable
 def single_target_shortest_path_length(G, target, cutoff=None):
     """Compute the shortest path lengths to target from all reachable nodes.
 
@@ -154,7 +154,7 @@ def single_target_shortest_path_length(G, target, cutoff=None):
     return dict(_single_shortest_path_length(adj, nextlevel, cutoff))
 
 
-@nx._dispatch
+@nx._dispatchable
 def all_pairs_shortest_path_length(G, cutoff=None):
     """Computes the shortest path lengths between all nodes in `G`.
 
@@ -199,7 +199,7 @@ def all_pairs_shortest_path_length(G, cutoff=None):
         yield (n, length(G, n, cutoff=cutoff))
 
 
-@nx._dispatch
+@nx._dispatchable
 def bidirectional_shortest_path(G, source, target):
     """Returns a list of nodes in a shortest path between source and target.
 
@@ -315,7 +315,7 @@ def _bidirectional_pred_succ(G, source, target):
     raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
 
 
-@nx._dispatch
+@nx._dispatchable
 def single_source_shortest_path(G, source, cutoff=None):
     """Compute shortest path between source
     and all other nodes reachable from source.
@@ -399,7 +399,7 @@ def _single_shortest_path(adj, firstlevel, paths, cutoff, join):
     return paths
 
 
-@nx._dispatch
+@nx._dispatchable
 def single_target_shortest_path(G, target, cutoff=None):
     """Compute shortest path to target from all nodes that reach target.
 
@@ -451,7 +451,7 @@ def join(p1, p2):
     return dict(_single_shortest_path(adj, nextlevel, paths, cutoff, join))
 
 
-@nx._dispatch
+@nx._dispatchable
 def all_pairs_shortest_path(G, cutoff=None):
     """Compute shortest paths between all nodes.
 
@@ -491,7 +491,7 @@ def all_pairs_shortest_path(G, cutoff=None):
         yield (n, single_source_shortest_path(G, n, cutoff=cutoff))
 
 
-@nx._dispatch
+@nx._dispatchable
 def predecessor(G, source, target=None, cutoff=None, return_seen=None):
     """Returns dict of predecessors for the path from source to all nodes in G.
 
diff --git a/networkx/algorithms/shortest_paths/weighted.py b/networkx/algorithms/shortest_paths/weighted.py
index bbbb03d9eee..e013fe24f83 100644
--- a/networkx/algorithms/shortest_paths/weighted.py
+++ b/networkx/algorithms/shortest_paths/weighted.py
@@ -78,7 +78,7 @@ def _weight_function(G, weight):
     return lambda u, v, data: data.get(weight, 1)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def dijkstra_path(G, source, target, weight="weight"):
     """Returns the shortest weighted path from source to target in G.
 
@@ -169,7 +169,7 @@ def dijkstra_path(G, source, target, weight="weight"):
     return path
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def dijkstra_path_length(G, source, target, weight="weight"):
     """Returns the shortest weighted path length in G from source to target.
 
@@ -249,7 +249,7 @@ def dijkstra_path_length(G, source, target, weight="weight"):
         raise nx.NetworkXNoPath(f"Node {target} not reachable from {source}") from err
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def single_source_dijkstra_path(G, source, cutoff=None, weight="weight"):
     """Find shortest weighted paths in G from a source node.
 
@@ -314,7 +314,7 @@ def single_source_dijkstra_path(G, source, cutoff=None, weight="weight"):
     return multi_source_dijkstra_path(G, {source}, cutoff=cutoff, weight=weight)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def single_source_dijkstra_path_length(G, source, cutoff=None, weight="weight"):
     """Find shortest weighted path lengths in G from a source node.
 
@@ -386,7 +386,7 @@ def single_source_dijkstra_path_length(G, source, cutoff=None, weight="weight"):
     return multi_source_dijkstra_path_length(G, {source}, cutoff=cutoff, weight=weight)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def single_source_dijkstra(G, source, target=None, cutoff=None, weight="weight"):
     """Find shortest weighted paths and lengths from a source node.
 
@@ -488,7 +488,7 @@ def single_source_dijkstra(G, source, target=None, cutoff=None, weight="weight")
     )
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def multi_source_dijkstra_path(G, sources, cutoff=None, weight="weight"):
     """Find shortest weighted paths in G from a given set of source
     nodes.
@@ -562,7 +562,7 @@ def multi_source_dijkstra_path(G, sources, cutoff=None, weight="weight"):
     return path
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def multi_source_dijkstra_path_length(G, sources, cutoff=None, weight="weight"):
     """Find shortest weighted path lengths in G from a given set of
     source nodes.
@@ -644,7 +644,7 @@ def multi_source_dijkstra_path_length(G, sources, cutoff=None, weight="weight"):
     return _dijkstra_multisource(G, sources, weight, cutoff=cutoff)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def multi_source_dijkstra(G, sources, target=None, cutoff=None, weight="weight"):
     """Find shortest weighted paths and lengths from a given set of
     source nodes.
@@ -881,7 +881,7 @@ def _dijkstra_multisource(
     return dist
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def dijkstra_predecessor_and_distance(G, source, cutoff=None, weight="weight"):
     """Compute weighted shortest path length and predecessors.
 
@@ -954,7 +954,7 @@ def dijkstra_predecessor_and_distance(G, source, cutoff=None, weight="weight"):
     return (pred, _dijkstra(G, source, weight, pred=pred, cutoff=cutoff))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def all_pairs_dijkstra(G, cutoff=None, weight="weight"):
     """Find shortest weighted paths and lengths between all nodes.
 
@@ -1023,7 +1023,7 @@ def all_pairs_dijkstra(G, cutoff=None, weight="weight"):
         yield (n, (dist, path))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def all_pairs_dijkstra_path_length(G, cutoff=None, weight="weight"):
     """Compute shortest path lengths between all nodes in a weighted graph.
 
@@ -1082,7 +1082,7 @@ def all_pairs_dijkstra_path_length(G, cutoff=None, weight="weight"):
         yield (n, length(G, n, cutoff=cutoff, weight=weight))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def all_pairs_dijkstra_path(G, cutoff=None, weight="weight"):
     """Compute shortest paths between all nodes in a weighted graph.
 
@@ -1136,7 +1136,7 @@ def all_pairs_dijkstra_path(G, cutoff=None, weight="weight"):
         yield (n, path(G, n, cutoff=cutoff, weight=weight))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def bellman_ford_predecessor_and_distance(
     G, source, target=None, weight="weight", heuristic=False
 ):
@@ -1484,7 +1484,7 @@ def _inner_bellman_ford(
     return None
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def bellman_ford_path(G, source, target, weight="weight"):
     """Returns the shortest path from source to target in a weighted graph G.
 
@@ -1543,7 +1543,7 @@ def bellman_ford_path(G, source, target, weight="weight"):
     return path
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def bellman_ford_path_length(G, source, target, weight="weight"):
     """Returns the shortest path length from source to target
     in a weighted graph.
@@ -1614,7 +1614,7 @@ def bellman_ford_path_length(G, source, target, weight="weight"):
         raise nx.NetworkXNoPath(f"node {target} not reachable from {source}") from err
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def single_source_bellman_ford_path(G, source, weight="weight"):
     """Compute shortest path between source and all other reachable
     nodes for a weighted graph.
@@ -1670,7 +1670,7 @@ def single_source_bellman_ford_path(G, source, weight="weight"):
     return path
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def single_source_bellman_ford_path_length(G, source, weight="weight"):
     """Compute the shortest path length between source and all other
     reachable nodes for a weighted graph.
@@ -1733,7 +1733,7 @@ def single_source_bellman_ford_path_length(G, source, weight="weight"):
     return _bellman_ford(G, [source], weight)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def single_source_bellman_ford(G, source, target=None, weight="weight"):
     """Compute shortest paths and lengths in a weighted graph G.
 
@@ -1827,7 +1827,7 @@ def single_source_bellman_ford(G, source, target=None, weight="weight"):
         raise nx.NetworkXNoPath(msg) from err
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def all_pairs_bellman_ford_path_length(G, weight="weight"):
     """Compute shortest path lengths between all nodes in a weighted graph.
 
@@ -1882,7 +1882,7 @@ def all_pairs_bellman_ford_path_length(G, weight="weight"):
         yield (n, dict(length(G, n, weight=weight)))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def all_pairs_bellman_ford_path(G, weight="weight"):
     """Compute shortest paths between all nodes in a weighted graph.
 
@@ -1932,7 +1932,7 @@ def all_pairs_bellman_ford_path(G, weight="weight"):
         yield (n, path(G, n, weight=weight))
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def goldberg_radzik(G, source, weight="weight"):
     """Compute shortest path lengths and predecessors on shortest paths
     in weighted graphs.
@@ -2119,7 +2119,7 @@ def relax(to_scan):
     return pred, d
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def negative_edge_cycle(G, weight="weight", heuristic=True):
     """Returns True if there exists a negative edge cycle anywhere in G.
 
@@ -2190,7 +2190,7 @@ def negative_edge_cycle(G, weight="weight", heuristic=True):
     return False
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def find_negative_cycle(G, source, weight="weight"):
     """Returns a cycle with negative total weight if it exists.
 
@@ -2283,7 +2283,7 @@ def find_negative_cycle(G, source, weight="weight"):
     raise nx.NetworkXUnbounded(msg)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def bidirectional_dijkstra(G, source, target, weight="weight"):
     r"""Dijkstra's algorithm for shortest paths using bidirectional search.
 
@@ -2431,7 +2431,7 @@ def bidirectional_dijkstra(G, source, target, weight="weight"):
     raise nx.NetworkXNoPath(f"No path between {source} and {target}.")
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def johnson(G, weight="weight"):
     r"""Uses Johnson's Algorithm to compute shortest paths.
 
diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index 183b41f66b6..e36d23dcb83 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -36,7 +36,7 @@ def debug_print(*args, **kwargs):
     print(*args, **kwargs)
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G1": 0, "G2": 1}, preserve_edge_attrs=True, preserve_node_attrs=True
 )
 def graph_edit_distance(
@@ -210,7 +210,7 @@ def graph_edit_distance(
     return bestcost
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1})
 def optimal_edit_paths(
     G1,
     G2,
@@ -382,7 +382,7 @@ def optimal_edit_paths(
     return paths, bestcost
 
 
-@nx._dispatch(graphs={"G1": 0, "G2": 1})
+@nx._dispatchable(graphs={"G1": 0, "G2": 1})
 def optimize_graph_edit_distance(
     G1,
     G2,
@@ -533,7 +533,7 @@ def optimize_graph_edit_distance(
         yield cost
 
 
-@nx._dispatch(
+@nx._dispatchable(
     graphs={"G1": 0, "G2": 1}, preserve_edge_attrs=True, preserve_node_attrs=True
 )
 def optimize_edit_paths(
@@ -1212,7 +1212,7 @@ def prune(cost):
         yield list(vertex_path), list(edge_path), cost
 
 
-@nx._dispatch
+@nx._dispatchable
 def simrank_similarity(
     G,
     source=None,
@@ -1525,7 +1525,7 @@ def _simrank_similarity_numpy(
     return newsim
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def panther_similarity(
     G, source, k=5, path_length=5, c=0.5, delta=0.1, eps=None, weight="weight"
 ):
@@ -1661,7 +1661,7 @@ def panther_similarity(
     return top_k_with_val
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def generate_random_paths(
     G, sample_size, path_length=5, index_map=None, weight="weight"
 ):
diff --git a/networkx/algorithms/simple_paths.py b/networkx/algorithms/simple_paths.py
index 6324ad67e2d..be0890339e7 100644
--- a/networkx/algorithms/simple_paths.py
+++ b/networkx/algorithms/simple_paths.py
@@ -13,7 +13,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_simple_path(G, nodes):
     """Returns True if and only if `nodes` form a simple path in `G`.
 
@@ -91,7 +91,7 @@ def is_simple_path(G, nodes):
     return all(v in G[u] for u, v in pairwise(nodes))
 
 
-@nx._dispatch
+@nx._dispatchable
 def all_simple_paths(G, source, target, cutoff=None):
     """Generate all simple paths in the graph G from source to target.
 
@@ -257,7 +257,7 @@ def all_simple_paths(G, source, target, cutoff=None):
         yield [source] + [edge[1] for edge in edge_path]
 
 
-@nx._dispatch
+@nx._dispatchable
 def all_simple_edge_paths(G, source, target, cutoff=None):
     """Generate lists of edges for all simple paths in G from source to target.
 
@@ -402,7 +402,7 @@ def _all_simple_edge_paths(G, source, targets, cutoff):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def shortest_simple_paths(G, source, target, weight=None):
     """Generate all simple paths in the graph G from source to target,
        starting from shortest ones.
diff --git a/networkx/algorithms/smallworld.py b/networkx/algorithms/smallworld.py
index 172c4f9a879..1c89e243e7d 100644
--- a/networkx/algorithms/smallworld.py
+++ b/networkx/algorithms/smallworld.py
@@ -23,7 +23,7 @@
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def random_reference(G, niter=1, connectivity=True, seed=None):
     """Compute a random graph by swapping edges of a given graph.
 
@@ -121,7 +121,7 @@ def random_reference(G, niter=1, connectivity=True, seed=None):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(4)
-@nx._dispatch
+@nx._dispatchable
 def lattice_reference(G, niter=5, D=None, connectivity=True, seed=None):
     """Latticize the given graph by swapping edges.
 
@@ -245,7 +245,7 @@ def lattice_reference(G, niter=5, D=None, connectivity=True, seed=None):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def sigma(G, niter=100, nrand=10, seed=None):
     """Returns the small-world coefficient (sigma) of the given graph.
 
@@ -314,7 +314,7 @@ def sigma(G, niter=100, nrand=10, seed=None):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def omega(G, niter=5, nrand=10, seed=None):
     """Returns the small-world coefficient (omega) of a graph
 
diff --git a/networkx/algorithms/smetric.py b/networkx/algorithms/smetric.py
index 80ae314bbdd..5a27014ee55 100644
--- a/networkx/algorithms/smetric.py
+++ b/networkx/algorithms/smetric.py
@@ -3,7 +3,7 @@
 __all__ = ["s_metric"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def s_metric(G, **kwargs):
     """Returns the s-metric [1]_ of graph.
 
diff --git a/networkx/algorithms/sparsifiers.py b/networkx/algorithms/sparsifiers.py
index 5890a5b1e9a..fedc16cdd2d 100644
--- a/networkx/algorithms/sparsifiers.py
+++ b/networkx/algorithms/sparsifiers.py
@@ -10,7 +10,7 @@
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(3)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def spanner(G, stretch, weight=None, seed=None):
     """Returns a spanner of the given graph with the given stretch.
 
diff --git a/networkx/algorithms/structuralholes.py b/networkx/algorithms/structuralholes.py
index 6d4f33171dd..bae42d060af 100644
--- a/networkx/algorithms/structuralholes.py
+++ b/networkx/algorithms/structuralholes.py
@@ -5,7 +5,7 @@
 __all__ = ["constraint", "local_constraint", "effective_size"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def mutual_weight(G, u, v, weight=None):
     """Returns the sum of the weights of the edge from `u` to `v` and
     the edge from `v` to `u` in `G`.
@@ -28,7 +28,7 @@ def mutual_weight(G, u, v, weight=None):
     return a_uv + a_vu
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def normalized_mutual_weight(G, u, v, norm=sum, weight=None):
     """Returns normalized mutual weight of the edges from `u` to `v`
     with respect to the mutual weights of the neighbors of `u` in `G`.
@@ -49,7 +49,7 @@ def normalized_mutual_weight(G, u, v, norm=sum, weight=None):
     return 0 if scale == 0 else mutual_weight(G, u, v, weight) / scale
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def effective_size(G, nodes=None, weight=None):
     r"""Returns the effective size of all nodes in the graph ``G``.
 
@@ -162,7 +162,7 @@ def redundancy(G, u, v, weight=None):
     return effective_size
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def constraint(G, nodes=None, weight=None):
     r"""Returns the constraint on all nodes in the graph ``G``.
 
@@ -223,7 +223,7 @@ def constraint(G, nodes=None, weight=None):
     return constraint
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def local_constraint(G, u, v, weight=None):
     r"""Returns the local constraint on the node ``u`` with respect to
     the node ``v`` in the graph ``G``.
diff --git a/networkx/algorithms/summarization.py b/networkx/algorithms/summarization.py
index 236810f0d98..f3364e32ee7 100644
--- a/networkx/algorithms/summarization.py
+++ b/networkx/algorithms/summarization.py
@@ -65,7 +65,7 @@
 __all__ = ["dedensify", "snap_aggregation"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def dedensify(G, threshold, prefix=None, copy=True):
     """Compresses neighborhoods around high-degree nodes
 
@@ -404,7 +404,7 @@ def _snap_split(groups, neighbor_info, group_lookup, group_id):
     return groups
 
 
-@nx._dispatch(node_attrs="[node_attributes]", edge_attrs="[edge_attributes]")
+@nx._dispatchable(node_attrs="[node_attributes]", edge_attrs="[edge_attributes]")
 def snap_aggregation(
     G,
     node_attributes,
diff --git a/networkx/algorithms/swap.py b/networkx/algorithms/swap.py
index 926be49831e..1b6133e4a69 100644
--- a/networkx/algorithms/swap.py
+++ b/networkx/algorithms/swap.py
@@ -11,7 +11,7 @@
 
 @nx.utils.not_implemented_for("undirected")
 @py_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def directed_edge_swap(G, *, nswap=1, max_tries=100, seed=None):
     """Swap three edges in a directed graph while keeping the node degrees fixed.
 
@@ -131,7 +131,7 @@ def directed_edge_swap(G, *, nswap=1, max_tries=100, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def double_edge_swap(G, nswap=1, max_tries=100, seed=None):
     """Swap two edges in the graph while keeping the node degrees fixed.
 
@@ -229,7 +229,7 @@ def double_edge_swap(G, nswap=1, max_tries=100, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def connected_double_edge_swap(G, nswap=1, _window_threshold=3, seed=None):
     """Attempts the specified number of double-edge swaps in the graph `G`.
 
diff --git a/networkx/algorithms/tests/test_structuralholes.py b/networkx/algorithms/tests/test_structuralholes.py
index 6f92baa4f32..215ce4530fa 100644
--- a/networkx/algorithms/tests/test_structuralholes.py
+++ b/networkx/algorithms/tests/test_structuralholes.py
@@ -52,7 +52,7 @@ def setup_method(self):
             ("G", "C"): 10,
         }
 
-    # This additionally tests the @nx._dispatch mechanism, treating
+    # This additionally tests the @nx._dispatchable mechanism, treating
     # nx.mutual_weight as if it were a re-implementation from another package
     @pytest.mark.parametrize("wrapper", [lambda x: x, dispatch_interface.convert])
     def test_constraint_directed(self, wrapper):
diff --git a/networkx/algorithms/threshold.py b/networkx/algorithms/threshold.py
index 0839321de0d..1eb35a2c528 100644
--- a/networkx/algorithms/threshold.py
+++ b/networkx/algorithms/threshold.py
@@ -9,7 +9,7 @@
 __all__ = ["is_threshold_graph", "find_threshold_graph"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_threshold_graph(G):
     """
     Returns `True` if `G` is a threshold graph.
@@ -301,7 +301,7 @@ def weights_to_creation_sequence(
 
 
 # Manipulating NetworkX.Graphs in context of threshold graphs
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def threshold_graph(creation_sequence, create_using=None):
     """
     Create a threshold graph from the creation sequence or compact
@@ -353,7 +353,7 @@ def threshold_graph(creation_sequence, create_using=None):
     return G
 
 
-@nx._dispatch
+@nx._dispatchable
 def find_alternating_4_cycle(G):
     """
     Returns False if there aren't any alternating 4 cycles.
@@ -369,7 +369,7 @@ def find_alternating_4_cycle(G):
     return False
 
 
-@nx._dispatch
+@nx._dispatchable
 def find_threshold_graph(G, create_using=None):
     """
     Returns a threshold subgraph that is close to largest in `G`.
@@ -404,7 +404,7 @@ def find_threshold_graph(G, create_using=None):
     return threshold_graph(find_creation_sequence(G), create_using)
 
 
-@nx._dispatch
+@nx._dispatchable
 def find_creation_sequence(G):
     """
     Find a threshold subgraph that is close to largest in G.
diff --git a/networkx/algorithms/time_dependent.py b/networkx/algorithms/time_dependent.py
index e83f42ad92c..597a3d157f3 100644
--- a/networkx/algorithms/time_dependent.py
+++ b/networkx/algorithms/time_dependent.py
@@ -8,7 +8,7 @@
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch(node_attrs={"time": None, "weight": 1})
+@nx._dispatchable(node_attrs={"time": None, "weight": 1})
 def cd_index(G, node, time_delta, *, time="time", weight=None):
     r"""Compute the CD index for `node` within the graph `G`.
 
diff --git a/networkx/algorithms/tournament.py b/networkx/algorithms/tournament.py
index 0b164cb3b16..6946afec799 100644
--- a/networkx/algorithms/tournament.py
+++ b/networkx/algorithms/tournament.py
@@ -65,7 +65,7 @@ def index_satisfying(iterable, condition):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def is_tournament(G):
     """Returns True if and only if `G` is a tournament.
 
@@ -104,7 +104,7 @@ def is_tournament(G):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def hamiltonian_path(G):
     """Returns a Hamiltonian path in the given tournament graph.
 
@@ -151,7 +151,7 @@ def hamiltonian_path(G):
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_tournament(n, seed=None):
     r"""Returns a random tournament graph on `n` nodes.
 
@@ -186,7 +186,7 @@ def random_tournament(n, seed=None):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def score_sequence(G):
     """Returns the score sequence for the given tournament graph.
 
@@ -217,7 +217,7 @@ def score_sequence(G):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def tournament_matrix(G):
     r"""Returns the tournament matrix for the given tournament graph.
 
@@ -260,7 +260,7 @@ def tournament_matrix(G):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def is_reachable(G, s, t):
     """Decides whether there is a path from `s` to `t` in the
     tournament.
@@ -349,7 +349,7 @@ def is_closed(G, nodes):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch(name="tournament_is_strongly_connected")
+@nx._dispatchable(name="tournament_is_strongly_connected")
 def is_strongly_connected(G):
     """Decides whether the given tournament is strongly connected.
 
diff --git a/networkx/algorithms/traversal/beamsearch.py b/networkx/algorithms/traversal/beamsearch.py
index 9b339e306f7..ab90f44aedb 100644
--- a/networkx/algorithms/traversal/beamsearch.py
+++ b/networkx/algorithms/traversal/beamsearch.py
@@ -4,7 +4,7 @@
 __all__ = ["bfs_beam_edges"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def bfs_beam_edges(G, source, value, width=None):
     """Iterates over edges in a beam search.
 
diff --git a/networkx/algorithms/traversal/breadth_first_search.py b/networkx/algorithms/traversal/breadth_first_search.py
index 989c7f8622d..09bc695759a 100644
--- a/networkx/algorithms/traversal/breadth_first_search.py
+++ b/networkx/algorithms/traversal/breadth_first_search.py
@@ -16,7 +16,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def generic_bfs_edges(G, source, neighbors=None, depth_limit=None, sort_neighbors=None):
     """Iterate over edges in a breadth-first search.
 
@@ -130,7 +130,7 @@ def generic_bfs_edges(G, source, neighbors=None, depth_limit=None, sort_neighbor
         depth += 1
 
 
-@nx._dispatch
+@nx._dispatchable
 def bfs_edges(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
     """Iterate over edges in a breadth-first-search starting at source.
 
@@ -218,7 +218,7 @@ def bfs_edges(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
         yield from generic_bfs_edges(G, source, successors, depth_limit)
 
 
-@nx._dispatch
+@nx._dispatchable
 def bfs_tree(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
     """Returns an oriented tree constructed from of a breadth-first-search
     starting at source.
@@ -285,7 +285,7 @@ def bfs_tree(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
     return T
 
 
-@nx._dispatch
+@nx._dispatchable
 def bfs_predecessors(G, source, depth_limit=None, sort_neighbors=None):
     """Returns an iterator of predecessors in breadth-first-search from source.
 
@@ -350,7 +350,7 @@ def bfs_predecessors(G, source, depth_limit=None, sort_neighbors=None):
         yield (t, s)
 
 
-@nx._dispatch
+@nx._dispatchable
 def bfs_successors(G, source, depth_limit=None, sort_neighbors=None):
     """Returns an iterator of successors in breadth-first-search from source.
 
@@ -423,7 +423,7 @@ def bfs_successors(G, source, depth_limit=None, sort_neighbors=None):
     yield (parent, children)
 
 
-@nx._dispatch
+@nx._dispatchable
 def bfs_layers(G, sources):
     """Returns an iterator of all the layers in breadth-first search traversal.
 
@@ -481,7 +481,7 @@ def bfs_layers(G, sources):
 LEVEL_EDGE = "level"
 
 
-@nx._dispatch
+@nx._dispatchable
 def bfs_labeled_edges(G, sources):
     """Iterate over edges in a breadth-first search (BFS) labeled by type.
 
@@ -556,7 +556,7 @@ def bfs_labeled_edges(G, sources):
         visit(u)
 
 
-@nx._dispatch
+@nx._dispatchable
 def descendants_at_distance(G, source, distance):
     """Returns all nodes at a fixed `distance` from `source` in `G`.
 
diff --git a/networkx/algorithms/traversal/depth_first_search.py b/networkx/algorithms/traversal/depth_first_search.py
index 185a99c3dd1..843a793aed6 100644
--- a/networkx/algorithms/traversal/depth_first_search.py
+++ b/networkx/algorithms/traversal/depth_first_search.py
@@ -14,7 +14,7 @@
 ]
 
 
-@nx._dispatch
+@nx._dispatchable
 def dfs_edges(G, source=None, depth_limit=None):
     """Iterate over edges in a depth-first-search (DFS).
 
@@ -100,7 +100,7 @@ def dfs_edges(G, source=None, depth_limit=None):
                 depth_now -= 1
 
 
-@nx._dispatch
+@nx._dispatchable
 def dfs_tree(G, source=None, depth_limit=None):
     """Returns oriented tree constructed from a depth-first-search from source.
 
@@ -146,7 +146,7 @@ def dfs_tree(G, source=None, depth_limit=None):
     return T
 
 
-@nx._dispatch
+@nx._dispatchable
 def dfs_predecessors(G, source=None, depth_limit=None):
     """Returns dictionary of predecessors in depth-first-search from source.
 
@@ -200,7 +200,7 @@ def dfs_predecessors(G, source=None, depth_limit=None):
     return {t: s for s, t in dfs_edges(G, source, depth_limit)}
 
 
-@nx._dispatch
+@nx._dispatchable
 def dfs_successors(G, source=None, depth_limit=None):
     """Returns dictionary of successors in depth-first-search from source.
 
@@ -257,7 +257,7 @@ def dfs_successors(G, source=None, depth_limit=None):
     return dict(d)
 
 
-@nx._dispatch
+@nx._dispatchable
 def dfs_postorder_nodes(G, source=None, depth_limit=None):
     """Generate nodes in a depth-first-search post-ordering starting at source.
 
@@ -309,7 +309,7 @@ def dfs_postorder_nodes(G, source=None, depth_limit=None):
     return (v for u, v, d in edges if d == "reverse")
 
 
-@nx._dispatch
+@nx._dispatchable
 def dfs_preorder_nodes(G, source=None, depth_limit=None):
     """Generate nodes in a depth-first-search pre-ordering starting at source.
 
@@ -361,7 +361,7 @@ def dfs_preorder_nodes(G, source=None, depth_limit=None):
     return (v for u, v, d in edges if d == "forward")
 
 
-@nx._dispatch
+@nx._dispatchable
 def dfs_labeled_edges(G, source=None, depth_limit=None):
     """Iterate over edges in a depth-first-search (DFS) labeled by type.
 
diff --git a/networkx/algorithms/traversal/edgebfs.py b/networkx/algorithms/traversal/edgebfs.py
index c29ef5e0269..484ae12b5ea 100644
--- a/networkx/algorithms/traversal/edgebfs.py
+++ b/networkx/algorithms/traversal/edgebfs.py
@@ -16,7 +16,7 @@
 __all__ = ["edge_bfs"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def edge_bfs(G, source=None, orientation=None):
     """A directed, breadth-first-search of edges in `G`, beginning at `source`.
 
diff --git a/networkx/algorithms/traversal/edgedfs.py b/networkx/algorithms/traversal/edgedfs.py
index 1e583de6ec4..010f68246c9 100644
--- a/networkx/algorithms/traversal/edgedfs.py
+++ b/networkx/algorithms/traversal/edgedfs.py
@@ -14,7 +14,7 @@
 __all__ = ["edge_dfs"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def edge_dfs(G, source=None, orientation=None):
     """A directed, depth-first-search of edges in `G`, beginning at `source`.
 
diff --git a/networkx/algorithms/tree/branchings.py b/networkx/algorithms/tree/branchings.py
index 653266915e7..eebc99a751b 100644
--- a/networkx/algorithms/tree/branchings.py
+++ b/networkx/algorithms/tree/branchings.py
@@ -73,7 +73,7 @@ def _max_weight(weight):
     return weight
 
 
-@nx._dispatch(edge_attrs={"attr": "default"})
+@nx._dispatchable(edge_attrs={"attr": "default"})
 def branching_weight(G, attr="weight", default=1):
     """
     Returns the total weight of a branching.
@@ -108,7 +108,7 @@ def branching_weight(G, attr="weight", default=1):
 
 
 @py_random_state(4)
-@nx._dispatch(edge_attrs={"attr": "default"})
+@nx._dispatchable(edge_attrs={"attr": "default"})
 def greedy_branching(G, attr="weight", default=1, kind="max", seed=None):
     """
     Returns a branching obtained through a greedy algorithm.
@@ -745,7 +745,7 @@ def is_root(G, u, edgekeys):
         return H
 
 
-@nx._dispatch(
+@nx._dispatchable(
     edge_attrs={"attr": "default", "partition": 0},
     preserve_edge_attrs="preserve_attrs",
 )
@@ -1173,7 +1173,7 @@ def is_root(G, u, edgekeys):
     return H
 
 
-@nx._dispatch(
+@nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
 )
@@ -1194,7 +1194,7 @@ def minimum_branching(
     return B
 
 
-@nx._dispatch(
+@nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
 )
@@ -1258,7 +1258,7 @@ def minimal_branching(
     return B
 
 
-@nx._dispatch(
+@nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
 )
@@ -1300,7 +1300,7 @@ def maximum_spanning_arborescence(
     return B
 
 
-@nx._dispatch(
+@nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
 )
diff --git a/networkx/algorithms/tree/coding.py b/networkx/algorithms/tree/coding.py
index a74fd48cff0..55344dbcbcf 100644
--- a/networkx/algorithms/tree/coding.py
+++ b/networkx/algorithms/tree/coding.py
@@ -32,7 +32,7 @@ class NotATree(nx.NetworkXException):
 
 
 @not_implemented_for("directed")
-@nx._dispatch(graphs="T")
+@nx._dispatchable(graphs="T")
 def to_nested_tuple(T, root, canonical_form=False):
     """Returns a nested tuple representation of the given tree.
 
@@ -128,7 +128,7 @@ def _make_tuple(T, root, _parent):
     return _make_tuple(T, root, None)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_nested_tuple(sequence, sensible_relabeling=False):
     """Returns the rooted tree corresponding to the given nested tuple.
 
@@ -213,7 +213,7 @@ def _make_tree(sequence):
 
 
 @not_implemented_for("directed")
-@nx._dispatch(graphs="T")
+@nx._dispatchable(graphs="T")
 def to_prufer_sequence(T):
     r"""Returns the Prüfer sequence of the given tree.
 
@@ -314,7 +314,7 @@ def parents(u):
     return result
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_prufer_sequence(sequence):
     r"""Returns the tree corresponding to the given Prüfer sequence.
 
diff --git a/networkx/algorithms/tree/decomposition.py b/networkx/algorithms/tree/decomposition.py
index 0517100016f..a649288ffe8 100644
--- a/networkx/algorithms/tree/decomposition.py
+++ b/networkx/algorithms/tree/decomposition.py
@@ -10,7 +10,7 @@
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def junction_tree(G):
     r"""Returns a junction tree of a given graph.
 
diff --git a/networkx/algorithms/tree/mst.py b/networkx/algorithms/tree/mst.py
index ee264d41ae5..8b76bc470ab 100644
--- a/networkx/algorithms/tree/mst.py
+++ b/networkx/algorithms/tree/mst.py
@@ -41,7 +41,7 @@ class EdgePartition(Enum):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight", preserve_edge_attrs="data")
+@nx._dispatchable(edge_attrs="weight", preserve_edge_attrs="data")
 def boruvka_mst_edges(
     G, minimum=True, weight="weight", keys=False, data=True, ignore_nan=False
 ):
@@ -138,7 +138,7 @@ def best_edge(component):
                 forest.union(u, v)
 
 
-@nx._dispatch(
+@nx._dispatchable(
     edge_attrs={"weight": None, "partition": None}, preserve_edge_attrs="data"
 )
 def kruskal_mst_edges(
@@ -251,7 +251,7 @@ def kruskal_mst_edges(
                 subtrees.union(u, v)
 
 
-@nx._dispatch(edge_attrs="weight", preserve_edge_attrs="data")
+@nx._dispatchable(edge_attrs="weight", preserve_edge_attrs="data")
 def prim_mst_edges(G, minimum, weight="weight", keys=True, data=True, ignore_nan=False):
     """Iterate over edges of Prim's algorithm min/max spanning tree.
 
@@ -367,7 +367,7 @@ def prim_mst_edges(G, minimum, weight="weight", keys=True, data=True, ignore_nan
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight", preserve_edge_attrs="data")
+@nx._dispatchable(edge_attrs="weight", preserve_edge_attrs="data")
 def minimum_spanning_edges(
     G, algorithm="kruskal", weight="weight", keys=True, data=True, ignore_nan=False
 ):
@@ -462,7 +462,7 @@ def minimum_spanning_edges(
 
 
 @not_implemented_for("directed")
-@nx._dispatch(edge_attrs="weight", preserve_edge_attrs="data")
+@nx._dispatchable(edge_attrs="weight", preserve_edge_attrs="data")
 def maximum_spanning_edges(
     G, algorithm="kruskal", weight="weight", keys=True, data=True, ignore_nan=False
 ):
@@ -555,7 +555,7 @@ def maximum_spanning_edges(
     )
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def minimum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=False):
     """Returns a minimum spanning tree or forest on an undirected graph `G`.
 
@@ -615,7 +615,7 @@ def minimum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=Fa
     return T
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def partition_spanning_tree(
     G, minimum=True, weight="weight", partition="partition", ignore_nan=False
 ):
@@ -679,7 +679,7 @@ def partition_spanning_tree(
     return T
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def maximum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=False):
     """Returns a maximum spanning tree or forest on an undirected graph `G`.
 
@@ -743,7 +743,7 @@ def maximum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=Fa
 
 
 @py_random_state(3)
-@nx._dispatch(preserve_edge_attrs=True)
+@nx._dispatchable(preserve_edge_attrs=True)
 def random_spanning_tree(G, weight=None, *, multiplicative=True, seed=None):
     """
     Sample a random spanning tree using the edges weights of `G`.
diff --git a/networkx/algorithms/tree/operations.py b/networkx/algorithms/tree/operations.py
index df1b4e7bec0..14b7c232bcf 100644
--- a/networkx/algorithms/tree/operations.py
+++ b/networkx/algorithms/tree/operations.py
@@ -32,7 +32,7 @@ def join(rooted_trees, label_attribute=None):
 
 
 # Argument types don't match dispatching, but allow manual selection of backend
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def join_trees(rooted_trees, *, label_attribute=None, first_label=0):
     """Returns a new rooted tree made by joining `rooted_trees`
 
diff --git a/networkx/algorithms/tree/recognition.py b/networkx/algorithms/tree/recognition.py
index 15bbdf7d83b..a9eae98707a 100644
--- a/networkx/algorithms/tree/recognition.py
+++ b/networkx/algorithms/tree/recognition.py
@@ -79,7 +79,7 @@
 
 
 @nx.utils.not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_arborescence(G):
     """
     Returns True if `G` is an arborescence.
@@ -119,7 +119,7 @@ def is_arborescence(G):
 
 
 @nx.utils.not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def is_branching(G):
     """
     Returns True if `G` is a branching.
@@ -158,7 +158,7 @@ def is_branching(G):
     return is_forest(G) and max(d for n, d in G.in_degree()) <= 1
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_forest(G):
     """
     Returns True if `G` is a forest.
@@ -215,7 +215,7 @@ def is_forest(G):
     return all(len(c) - 1 == c.number_of_edges() for c in components)
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_tree(G):
     """
     Returns True if `G` is a tree.
diff --git a/networkx/algorithms/triads.py b/networkx/algorithms/triads.py
index 07172465dae..c2cdf2e8008 100644
--- a/networkx/algorithms/triads.py
+++ b/networkx/algorithms/triads.py
@@ -129,7 +129,7 @@ def _tricode(G, v, u, w):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def triadic_census(G, nodelist=None):
     """Determines the triadic census of a directed graph.
 
@@ -281,7 +281,7 @@ def triadic_census(G, nodelist=None):
     return census
 
 
-@nx._dispatch
+@nx._dispatchable
 def is_triad(G):
     """Returns True if the graph G is a triad, else False.
 
@@ -312,7 +312,7 @@ def is_triad(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def all_triplets(G):
     """Returns a generator of all possible sets of 3 nodes in a DiGraph.
 
@@ -355,7 +355,7 @@ def all_triplets(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def all_triads(G):
     """A generator of all possible triads in G.
 
@@ -386,7 +386,7 @@ def all_triads(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def triads_by_type(G):
     """Returns a list of all triads for each triad type in a directed graph.
     There are exactly 16 different types of triads possible. Suppose 1, 2, 3 are three
@@ -449,7 +449,7 @@ def triads_by_type(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatch
+@nx._dispatchable
 def triad_type(G):
     """Returns the sociological triad type for a triad.
 
@@ -548,7 +548,7 @@ def triad_type(G):
 
 @not_implemented_for("undirected")
 @py_random_state(1)
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def random_triad(G, seed=None):
     """Returns a random triad from a directed graph.
 
diff --git a/networkx/algorithms/vitality.py b/networkx/algorithms/vitality.py
index c41efd13f2c..29f98fd1bae 100644
--- a/networkx/algorithms/vitality.py
+++ b/networkx/algorithms/vitality.py
@@ -8,7 +8,7 @@
 __all__ = ["closeness_vitality"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def closeness_vitality(G, node=None, weight=None, wiener_index=None):
     """Returns the closeness vitality for nodes in the graph.
 
diff --git a/networkx/algorithms/voronoi.py b/networkx/algorithms/voronoi.py
index af17f013ec8..60c45332339 100644
--- a/networkx/algorithms/voronoi.py
+++ b/networkx/algorithms/voronoi.py
@@ -5,7 +5,7 @@
 __all__ = ["voronoi_cells"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def voronoi_cells(G, center_nodes, weight="weight"):
     """Returns the Voronoi cells centered at `center_nodes` with respect
     to the shortest-path distance metric.
diff --git a/networkx/algorithms/walks.py b/networkx/algorithms/walks.py
index 6f357ce1d42..91214c8e778 100644
--- a/networkx/algorithms/walks.py
+++ b/networkx/algorithms/walks.py
@@ -6,7 +6,7 @@
 __all__ = ["number_of_walks"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def number_of_walks(G, walk_length):
     """Returns the number of walks connecting each pair of nodes in `G`
 
diff --git a/networkx/algorithms/wiener.py b/networkx/algorithms/wiener.py
index 9e81cdc72ca..dd998ea33c0 100644
--- a/networkx/algorithms/wiener.py
+++ b/networkx/algorithms/wiener.py
@@ -14,7 +14,7 @@
 chaini = chain.from_iterable
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def wiener_index(G, weight=None):
     """Returns the Wiener index of the given graph.
 
diff --git a/networkx/classes/tests/dispatch_interface.py b/networkx/classes/tests/dispatch_interface.py
index 5cef755241b..96c363b93bb 100644
--- a/networkx/classes/tests/dispatch_interface.py
+++ b/networkx/classes/tests/dispatch_interface.py
@@ -6,7 +6,7 @@
 # This is comprehensive, but only tests the `test_override_dispatch`
 # function in networkx.classes.backends.
 
-# To test the `_dispatch` function directly, several tests scattered throughout
+# To test the `_dispatchable` function directly, several tests scattered throughout
 # NetworkX have been augmented to test normal and dispatch mode.
 # Searching for `dispatch_interface` should locate the specific tests.
 
diff --git a/networkx/classes/tests/test_backends.py b/networkx/classes/tests/test_backends.py
index 7adb7009aef..e1a7c1cf6ff 100644
--- a/networkx/classes/tests/test_backends.py
+++ b/networkx/classes/tests/test_backends.py
@@ -23,8 +23,8 @@ def test_pickle():
 
 
 @pytest.mark.skipif(
-    "not nx._dispatch._automatic_backends "
-    "or nx._dispatch._automatic_backends[0] != 'nx-loopback'"
+    "not nx._dispatchable._automatic_backends "
+    "or nx._dispatchable._automatic_backends[0] != 'nx-loopback'"
 )
 def test_graph_converter_needs_backend():
     # When testing, `nx.from_scipy_sparse_array` will *always* call the backend
diff --git a/networkx/conftest.py b/networkx/conftest.py
index 86cea45f944..1f045517575 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -46,11 +46,11 @@ def pytest_configure(config):
     if backend is None:
         backend = os.environ.get("NETWORKX_TEST_BACKEND")
     if backend:
-        networkx.utils.backends._dispatch._automatic_backends = [backend]
+        networkx.utils.backends._dispatchable._automatic_backends = [backend]
         fallback_to_nx = config.getoption("--fallback-to-nx")
         if not fallback_to_nx:
             fallback_to_nx = os.environ.get("NETWORKX_FALLBACK_TO_NX")
-        networkx.utils.backends._dispatch._fallback_to_nx = bool(fallback_to_nx)
+        networkx.utils.backends._dispatchable._fallback_to_nx = bool(fallback_to_nx)
     # nx-loopback backend is only available when testing
     backends = entry_points(name="nx-loopback", group="networkx.backends")
     if backends:
@@ -69,8 +69,8 @@ def pytest_configure(config):
 def pytest_collection_modifyitems(config, items):
     # Setting this to True here allows tests to be set up before dispatching
     # any function call to a backend.
-    networkx.utils.backends._dispatch._is_testing = True
-    if automatic_backends := networkx.utils.backends._dispatch._automatic_backends:
+    networkx.utils.backends._dispatchable._is_testing = True
+    if automatic_backends := networkx.utils.backends._dispatchable._automatic_backends:
         # Allow pluggable backends to add markers to tests (such as skip or xfail)
         # when running in auto-conversion test mode
         backend = networkx.utils.backends.backends[automatic_backends[0]].load()
diff --git a/networkx/convert.py b/networkx/convert.py
index 14598024684..f62df458e07 100644
--- a/networkx/convert.py
+++ b/networkx/convert.py
@@ -176,7 +176,7 @@ def to_networkx_graph(data, create_using=None, multigraph_input=False):
     raise nx.NetworkXError("Input is not a known data type for conversion.")
 
 
-@nx._dispatch
+@nx._dispatchable
 def to_dict_of_lists(G, nodelist=None):
     """Returns adjacency representation of graph as a dictionary of lists.
 
@@ -202,7 +202,7 @@ def to_dict_of_lists(G, nodelist=None):
     return d
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_dict_of_lists(d, create_using=None):
     """Returns a graph from a dictionary of lists.
 
@@ -364,7 +364,7 @@ def to_dict_of_dicts(G, nodelist=None, edge_data=None):
     return dod
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_dict_of_dicts(d, create_using=None, multigraph_input=False):
     """Returns a graph from a dictionary of dictionaries.
 
@@ -451,7 +451,7 @@ def from_dict_of_dicts(d, create_using=None, multigraph_input=False):
     return G
 
 
-@nx._dispatch(preserve_edge_attrs=True)
+@nx._dispatchable(preserve_edge_attrs=True)
 def to_edgelist(G, nodelist=None):
     """Returns a list of edges in the graph.
 
@@ -469,7 +469,7 @@ def to_edgelist(G, nodelist=None):
     return G.edges(nodelist, data=True)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_edgelist(edgelist, create_using=None):
     """Returns a graph from a list of edges.
 
diff --git a/networkx/convert_matrix.py b/networkx/convert_matrix.py
index c731985bb9f..ae756e59934 100644
--- a/networkx/convert_matrix.py
+++ b/networkx/convert_matrix.py
@@ -43,7 +43,7 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def to_pandas_adjacency(
     G,
     nodelist=None,
@@ -150,7 +150,7 @@ def to_pandas_adjacency(
     return pd.DataFrame(data=M, index=nodelist, columns=nodelist)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_pandas_adjacency(df, create_using=None):
     r"""Returns a graph from Pandas DataFrame.
 
@@ -219,7 +219,7 @@ def from_pandas_adjacency(df, create_using=None):
     return G
 
 
-@nx._dispatch(preserve_edge_attrs=True)
+@nx._dispatchable(preserve_edge_attrs=True)
 def to_pandas_edgelist(
     G,
     source="source",
@@ -311,7 +311,7 @@ def to_pandas_edgelist(
     return pd.DataFrame(edgelistdict, dtype=dtype)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_pandas_edgelist(
     df,
     source="source",
@@ -483,7 +483,7 @@ def from_pandas_edgelist(
     return g
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def to_scipy_sparse_array(G, nodelist=None, dtype=None, weight="weight", format="csr"):
     """Returns the graph adjacency matrix as a SciPy sparse array.
 
@@ -675,7 +675,7 @@ def _generate_weighted_edges(A):
     return _coo_gen_triples(A.tocoo())
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_scipy_sparse_array(
     A, parallel_edges=False, create_using=None, edge_attribute="weight"
 ):
@@ -780,7 +780,7 @@ def from_scipy_sparse_array(
     return G
 
 
-@nx._dispatch(edge_attrs="weight")  # edge attrs may also be obtained from `dtype`
+@nx._dispatchable(edge_attrs="weight")  # edge attrs may also be obtained from `dtype`
 def to_numpy_array(
     G,
     nodelist=None,
@@ -1019,7 +1019,7 @@ def to_numpy_array(
     return A
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_numpy_array(A, parallel_edges=False, create_using=None, edge_attr="weight"):
     """Returns a graph from a 2D NumPy array.
 
diff --git a/networkx/drawing/nx_agraph.py b/networkx/drawing/nx_agraph.py
index da0758493f3..1682c62dcf1 100644
--- a/networkx/drawing/nx_agraph.py
+++ b/networkx/drawing/nx_agraph.py
@@ -33,7 +33,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_agraph(A, create_using=None):
     """Returns a NetworkX Graph or DiGraph from a PyGraphviz graph.
 
@@ -203,7 +203,7 @@ def write_dot(G, path):
     return
 
 
-@nx._dispatch(name="agraph_read_dot", graphs=None)
+@nx._dispatchable(name="agraph_read_dot", graphs=None)
 def read_dot(path):
     """Returns a NetworkX graph from a dot file on path.
 
diff --git a/networkx/drawing/nx_pydot.py b/networkx/drawing/nx_pydot.py
index 4e6a4dccf52..928970d83d0 100644
--- a/networkx/drawing/nx_pydot.py
+++ b/networkx/drawing/nx_pydot.py
@@ -46,7 +46,7 @@ def write_dot(G, path):
 
 
 @open_file(0, mode="r")
-@nx._dispatch(name="pydot_read_dot", graphs=None)
+@nx._dispatchable(name="pydot_read_dot", graphs=None)
 def read_dot(path):
     """Returns a NetworkX :class:`MultiGraph` or :class:`MultiDiGraph` from the
     dot file with the passed path.
@@ -80,7 +80,7 @@ def read_dot(path):
     return from_pydot(P_list[0])
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_pydot(P):
     """Returns a NetworkX graph from a Pydot graph.
 
diff --git a/networkx/generators/atlas.py b/networkx/generators/atlas.py
index 8e57ec98b2e..0a34bc466b8 100644
--- a/networkx/generators/atlas.py
+++ b/networkx/generators/atlas.py
@@ -88,7 +88,7 @@ def _generate_graphs():
             yield G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def graph_atlas(i):
     """Returns graph number `i` from the Graph Atlas.
 
@@ -127,7 +127,7 @@ def graph_atlas(i):
     return next(islice(_generate_graphs(), i, None))
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def graph_atlas_g():
     """Returns the list of all graphs with up to seven nodes named in the
     Graph Atlas.
diff --git a/networkx/generators/classic.py b/networkx/generators/classic.py
index 4bb660b5a8a..e220f82d8fd 100644
--- a/networkx/generators/classic.py
+++ b/networkx/generators/classic.py
@@ -65,7 +65,7 @@ def _tree_edges(n, r):
                 break
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def full_rary_tree(r, n, create_using=None):
     """Creates a full r-ary tree of `n` nodes.
 
@@ -103,7 +103,7 @@ def full_rary_tree(r, n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def balanced_tree(r, h, create_using=None):
     """Returns the perfectly balanced `r`-ary tree of height `h`.
 
@@ -153,7 +153,7 @@ def balanced_tree(r, h, create_using=None):
     return full_rary_tree(r, n, create_using=create_using)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def barbell_graph(m1, m2, create_using=None):
     """Returns the Barbell Graph: two complete graphs connected by a path.
 
@@ -226,7 +226,7 @@ def barbell_graph(m1, m2, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def binomial_tree(n, create_using=None):
     """Returns the Binomial Tree of order n.
 
@@ -264,7 +264,7 @@ def binomial_tree(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number(0)
 def complete_graph(n, create_using=None):
     """Return the complete graph `K_n` with n nodes.
@@ -312,7 +312,7 @@ def complete_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def circular_ladder_graph(n, create_using=None):
     """Returns the circular ladder graph $CL_n$ of length n.
 
@@ -332,7 +332,7 @@ def circular_ladder_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def circulant_graph(n, offsets, create_using=None):
     r"""Returns the circulant graph $Ci_n(x_1, x_2, ..., x_m)$ with $n$ nodes.
 
@@ -409,7 +409,7 @@ def circulant_graph(n, offsets, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number(0)
 def cycle_graph(n, create_using=None):
     """Returns the cycle graph $C_n$ of cyclically connected nodes.
@@ -441,7 +441,7 @@ def cycle_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def dorogovtsev_goltsev_mendes_graph(n, create_using=None):
     """Returns the hierarchically constructed Dorogovtsev-Goltsev-Mendes graph.
 
@@ -503,7 +503,7 @@ def dorogovtsev_goltsev_mendes_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number(0)
 def empty_graph(n=0, create_using=None, default=Graph):
     """Returns the empty graph with n nodes and zero edges.
@@ -602,7 +602,7 @@ def empty_graph(n=0, create_using=None, default=Graph):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def ladder_graph(n, create_using=None):
     """Returns the Ladder graph of length n.
 
@@ -625,7 +625,7 @@ def ladder_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number([0, 1])
 def lollipop_graph(m, n, create_using=None):
     """Returns the Lollipop Graph; ``K_m`` connected to ``P_n``.
@@ -692,7 +692,7 @@ def lollipop_graph(m, n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def null_graph(create_using=None):
     """Returns the Null graph with no nodes or edges.
 
@@ -703,7 +703,7 @@ def null_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number(0)
 def path_graph(n, create_using=None):
     """Returns the Path graph `P_n` of linearly connected nodes.
@@ -729,7 +729,7 @@ def path_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number(0)
 def star_graph(n, create_using=None):
     """Return the star graph
@@ -768,7 +768,7 @@ def star_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number([0, 1])
 def tadpole_graph(m, n, create_using=None):
     """Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
@@ -830,7 +830,7 @@ def tadpole_graph(m, n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def trivial_graph(create_using=None):
     """Return the Trivial graph with one node (with label 0) and no edges.
 
@@ -843,7 +843,7 @@ def trivial_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def turan_graph(n, r):
     r"""Return the Turan Graph
 
@@ -881,7 +881,7 @@ def turan_graph(n, r):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number(0)
 def wheel_graph(n, create_using=None):
     """Return the wheel graph
@@ -917,7 +917,7 @@ def wheel_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def complete_multipartite_graph(*subset_sizes):
     """Returns the complete multipartite graph with the specified subset sizes.
 
diff --git a/networkx/generators/cographs.py b/networkx/generators/cographs.py
index cb1f8d71b13..50f38ed76bf 100644
--- a/networkx/generators/cographs.py
+++ b/networkx/generators/cographs.py
@@ -18,7 +18,7 @@
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_cograph(n, seed=None):
     r"""Returns a random cograph with $2 ^ n$ nodes.
 
diff --git a/networkx/generators/community.py b/networkx/generators/community.py
index 0873b804958..5293fdf1181 100644
--- a/networkx/generators/community.py
+++ b/networkx/generators/community.py
@@ -19,7 +19,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def caveman_graph(l, k):
     """Returns a caveman graph of `l` cliques of size `k`.
 
@@ -66,7 +66,7 @@ def caveman_graph(l, k):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def connected_caveman_graph(l, k):
     """Returns a connected caveman graph of `l` cliques of size `k`.
 
@@ -121,7 +121,7 @@ def connected_caveman_graph(l, k):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def relaxed_caveman_graph(l, k, p, seed=None):
     """Returns a relaxed caveman graph.
 
@@ -173,7 +173,7 @@ def relaxed_caveman_graph(l, k, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_partition_graph(sizes, p_in, p_out, seed=None, directed=False):
     """Returns the random partition graph with a partition of sizes.
 
@@ -252,7 +252,7 @@ def random_partition_graph(sizes, p_in, p_out, seed=None, directed=False):
 
 
 @py_random_state(4)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def planted_partition_graph(l, k, p_in, p_out, seed=None, directed=False):
     """Returns the planted l-partition graph.
 
@@ -308,7 +308,7 @@ def planted_partition_graph(l, k, p_in, p_out, seed=None, directed=False):
 
 
 @py_random_state(6)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def gaussian_random_partition_graph(n, s, v, p_in, p_out, directed=False, seed=None):
     """Generate a Gaussian random partition graph.
 
@@ -384,7 +384,7 @@ def gaussian_random_partition_graph(n, s, v, p_in, p_out, directed=False, seed=N
     return random_partition_graph(sizes, p_in, p_out, seed=seed, directed=directed)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def ring_of_cliques(num_cliques, clique_size):
     """Defines a "ring of cliques" graph.
 
@@ -440,7 +440,7 @@ def ring_of_cliques(num_cliques, clique_size):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def windmill_graph(n, k):
     """Generate a windmill graph.
     A windmill graph is a graph of `n` cliques each of size `k` that are all
@@ -494,7 +494,7 @@ def windmill_graph(n, k):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def stochastic_block_model(
     sizes, p, nodelist=None, seed=None, directed=False, selfloops=False, sparse=True
 ):
@@ -808,7 +808,7 @@ def _generate_communities(degree_seq, community_sizes, mu, max_iters, seed):
 
 
 @py_random_state(11)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def LFR_benchmark_graph(
     n,
     tau1,
diff --git a/networkx/generators/degree_seq.py b/networkx/generators/degree_seq.py
index fd969110189..0e9414dd881 100644
--- a/networkx/generators/degree_seq.py
+++ b/networkx/generators/degree_seq.py
@@ -124,7 +124,7 @@ def _configuration_model(
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def configuration_model(deg_sequence, create_using=None, seed=None):
     """Returns a random graph with the given degree sequence.
 
@@ -227,7 +227,7 @@ def configuration_model(deg_sequence, create_using=None, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def directed_configuration_model(
     in_degree_sequence, out_degree_sequence, create_using=None, seed=None
 ):
@@ -330,7 +330,7 @@ def directed_configuration_model(
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def expected_degree_graph(w, seed=None, selfloops=True):
     r"""Returns a random graph with given expected degrees.
 
@@ -439,7 +439,7 @@ def expected_degree_graph(w, seed=None, selfloops=True):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def havel_hakimi_graph(deg_sequence, create_using=None):
     """Returns a simple graph with given degree sequence constructed
     using the Havel-Hakimi algorithm.
@@ -532,7 +532,7 @@ def havel_hakimi_graph(deg_sequence, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def directed_havel_hakimi_graph(in_deg_sequence, out_deg_sequence, create_using=None):
     """Returns a directed graph with the given degree sequences.
 
@@ -644,7 +644,7 @@ def directed_havel_hakimi_graph(in_deg_sequence, out_deg_sequence, create_using=
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def degree_sequence_tree(deg_sequence, create_using=None):
     """Make a tree for the given degree sequence.
 
@@ -691,7 +691,7 @@ def degree_sequence_tree(deg_sequence, create_using=None):
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_degree_sequence_graph(sequence, seed=None, tries=10):
     r"""Returns a simple random graph with the given degree sequence.
 
diff --git a/networkx/generators/directed.py b/networkx/generators/directed.py
index e084ebe8c4f..025d7957dcc 100644
--- a/networkx/generators/directed.py
+++ b/networkx/generators/directed.py
@@ -21,7 +21,7 @@
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def gn_graph(n, kernel=None, create_using=None, seed=None):
     """Returns the growing network (GN) digraph with `n` nodes.
 
@@ -89,7 +89,7 @@ def kernel(x):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def gnr_graph(n, p, create_using=None, seed=None):
     """Returns the growing network with redirection (GNR) digraph with `n`
     nodes and redirection probability `p`.
@@ -143,7 +143,7 @@ def gnr_graph(n, p, create_using=None, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def gnc_graph(n, create_using=None, seed=None):
     """Returns the growing network with copying (GNC) digraph with `n` nodes.
 
@@ -183,7 +183,7 @@ def gnc_graph(n, create_using=None, seed=None):
 
 
 @py_random_state(6)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def scale_free_graph(
     n,
     alpha=0.41,
@@ -334,7 +334,7 @@ def _choose_node(candidates, node_list, delta):
 
 
 @py_random_state(4)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_uniform_k_out_graph(n, k, self_loops=True, with_replacement=True, seed=None):
     """Returns a random `k`-out graph with uniform attachment.
 
@@ -415,7 +415,7 @@ def sample(v, nodes):
 
 
 @py_random_state(4)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_k_out_graph(n, k, alpha, self_loops=True, seed=None):
     """Returns a random `k`-out graph with preferential attachment.
 
diff --git a/networkx/generators/duplication.py b/networkx/generators/duplication.py
index ef7f374bbda..6a2e5d57e07 100644
--- a/networkx/generators/duplication.py
+++ b/networkx/generators/duplication.py
@@ -13,7 +13,7 @@
 
 
 @py_random_state(4)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def partial_duplication_graph(N, n, p, q, seed=None):
     """Returns a random graph using the partial duplication model.
 
@@ -88,7 +88,7 @@ def partial_duplication_graph(N, n, p, q, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def duplication_divergence_graph(n, p, seed=None):
     """Returns an undirected graph using the duplication-divergence model.
 
diff --git a/networkx/generators/ego.py b/networkx/generators/ego.py
index ab9ed257cc8..9803783ae1e 100644
--- a/networkx/generators/ego.py
+++ b/networkx/generators/ego.py
@@ -6,7 +6,7 @@
 import networkx as nx
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def ego_graph(G, n, radius=1, center=True, undirected=False, distance=None):
     """Returns induced subgraph of neighbors centered at node n within
     a given radius.
diff --git a/networkx/generators/expanders.py b/networkx/generators/expanders.py
index 2cd7976025a..33522ef550f 100644
--- a/networkx/generators/expanders.py
+++ b/networkx/generators/expanders.py
@@ -47,7 +47,7 @@
 #     (x, (y + (2*x + 1)) % n),
 #     (x, (y + (2*x + 2)) % n),
 #
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def margulis_gabber_galil_graph(n, create_using=None):
     r"""Returns the Margulis-Gabber-Galil undirected MultiGraph on `n^2` nodes.
 
@@ -90,7 +90,7 @@ def margulis_gabber_galil_graph(n, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def chordal_cycle_graph(p, create_using=None):
     """Returns the chordal cycle graph on `p` nodes.
 
@@ -154,7 +154,7 @@ def chordal_cycle_graph(p, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def paley_graph(p, create_using=None):
     r"""Returns the Paley $\frac{(p-1)}{2}$ -regular graph on $p$ nodes.
 
diff --git a/networkx/generators/geometric.py b/networkx/generators/geometric.py
index 052d96e3a71..4035a1ea5c5 100644
--- a/networkx/generators/geometric.py
+++ b/networkx/generators/geometric.py
@@ -20,7 +20,7 @@
 ]
 
 
-@nx._dispatch(node_attrs="pos_name")
+@nx._dispatchable(node_attrs="pos_name")
 def geometric_edges(G, radius, p=2, *, pos_name="pos"):
     """Returns edge list of node pairs within `radius` of each other.
 
@@ -111,7 +111,7 @@ def _geometric_edges(G, radius, p, pos_name):
 
 
 @py_random_state(5)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_geometric_graph(
     n, radius, dim=2, pos=None, p=2, seed=None, *, pos_name="pos"
 ):
@@ -205,7 +205,7 @@ def random_geometric_graph(
 
 
 @py_random_state(6)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def soft_random_geometric_graph(
     n, radius, dim=2, pos=None, p=2, p_dist=None, seed=None, *, pos_name="pos"
 ):
@@ -335,7 +335,7 @@ def should_join(edge):
 
 
 @py_random_state(7)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def geographical_threshold_graph(
     n,
     theta,
@@ -502,7 +502,7 @@ def should_join(pair):
 
 
 @py_random_state(6)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def waxman_graph(
     n,
     beta=0.4,
@@ -635,7 +635,7 @@ def should_join(pair):
 
 
 @py_random_state(5)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def navigable_small_world_graph(n, p=1, q=1, r=2, dim=2, seed=None):
     r"""Returns a navigable small-world graph.
 
@@ -708,7 +708,7 @@ def navigable_small_world_graph(n, p=1, q=1, r=2, dim=2, seed=None):
 
 
 @py_random_state(7)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def thresholded_random_geometric_graph(
     n,
     radius,
@@ -848,7 +848,7 @@ def thresholded_random_geometric_graph(
 
 
 @py_random_state(5)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def geometric_soft_configuration_graph(
     *, beta, n=None, gamma=None, mean_degree=None, kappas=None, seed=None
 ):
diff --git a/networkx/generators/harary_graph.py b/networkx/generators/harary_graph.py
index c752fab05f6..250f98985d6 100644
--- a/networkx/generators/harary_graph.py
+++ b/networkx/generators/harary_graph.py
@@ -21,7 +21,7 @@
 __all__ = ["hnm_harary_graph", "hkn_harary_graph"]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def hnm_harary_graph(n, m, create_using=None):
     """Returns the Harary graph with given numbers of nodes and edges.
 
@@ -113,7 +113,7 @@ def hnm_harary_graph(n, m, create_using=None):
     return H
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def hkn_harary_graph(k, n, create_using=None):
     """Returns the Harary graph with given node connectivity and node number.
 
diff --git a/networkx/generators/internet_as_graphs.py b/networkx/generators/internet_as_graphs.py
index 90e90203e0b..ad45b23d93e 100644
--- a/networkx/generators/internet_as_graphs.py
+++ b/networkx/generators/internet_as_graphs.py
@@ -397,7 +397,7 @@ def generate(self):
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_internet_as_graph(n, seed=None):
     """Generates a random undirected graph resembling the Internet AS network
 
diff --git a/networkx/generators/intersection.py b/networkx/generators/intersection.py
index 1bbcf156b04..be88448f066 100644
--- a/networkx/generators/intersection.py
+++ b/networkx/generators/intersection.py
@@ -12,7 +12,7 @@
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def uniform_random_intersection_graph(n, m, p, seed=None):
     """Returns a uniform random intersection graph.
 
@@ -48,7 +48,7 @@ def uniform_random_intersection_graph(n, m, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def k_random_intersection_graph(n, m, k, seed=None):
     """Returns a intersection graph with randomly chosen attribute sets for
     each node that are of equal size (k).
@@ -84,7 +84,7 @@ def k_random_intersection_graph(n, m, k, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def general_random_intersection_graph(n, m, p, seed=None):
     """Returns a random intersection graph with independent probabilities
     for connections between node and attribute sets.
diff --git a/networkx/generators/interval_graph.py b/networkx/generators/interval_graph.py
index c0efb34508a..6373a24b34c 100644
--- a/networkx/generators/interval_graph.py
+++ b/networkx/generators/interval_graph.py
@@ -8,7 +8,7 @@
 __all__ = ["interval_graph"]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def interval_graph(intervals):
     """Generates an interval graph for a list of intervals given.
 
diff --git a/networkx/generators/joint_degree_seq.py b/networkx/generators/joint_degree_seq.py
index fd2d56eba5f..7ad03288c86 100644
--- a/networkx/generators/joint_degree_seq.py
+++ b/networkx/generators/joint_degree_seq.py
@@ -11,7 +11,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_valid_joint_degree(joint_degrees):
     """Checks whether the given joint degree dictionary is realizable.
 
@@ -142,7 +142,7 @@ def _neighbor_switch(G, w, unsat, h_node_residual, avoid_node_id=None):
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def joint_degree_graph(joint_degrees, seed=None):
     """Generates a random simple graph with the given joint degree dictionary.
 
@@ -285,7 +285,7 @@ def joint_degree_graph(joint_degrees, seed=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def is_valid_directed_joint_degree(in_degrees, out_degrees, nkk):
     """Checks whether the given directed joint degree input is realizable
 
@@ -469,7 +469,7 @@ def _directed_neighbor_switch_rev(
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def directed_joint_degree_graph(in_degrees, out_degrees, nkk, seed=None):
     """Generates a random simple directed graph with the joint degree.
 
diff --git a/networkx/generators/lattice.py b/networkx/generators/lattice.py
index ba1f204af14..c046b8e9b11 100644
--- a/networkx/generators/lattice.py
+++ b/networkx/generators/lattice.py
@@ -32,7 +32,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 @nodes_or_number([0, 1])
 def grid_2d_graph(m, n, periodic=False, create_using=None):
     """Returns the two-dimensional grid graph.
@@ -86,7 +86,7 @@ def grid_2d_graph(m, n, periodic=False, create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def grid_graph(dim, periodic=False):
     """Returns the *n*-dimensional grid graph.
 
@@ -143,7 +143,7 @@ def grid_graph(dim, periodic=False):
     return H
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def hypercube_graph(n):
     """Returns the *n*-dimensional hypercube graph.
 
@@ -170,7 +170,7 @@ def hypercube_graph(n):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def triangular_lattice_graph(
     m, n, periodic=False, with_positions=True, create_using=None
 ):
@@ -271,7 +271,7 @@ def triangular_lattice_graph(
     return H
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def hexagonal_lattice_graph(
     m, n, periodic=False, with_positions=True, create_using=None
 ):
diff --git a/networkx/generators/line.py b/networkx/generators/line.py
index ccee9605584..83c6481fe43 100644
--- a/networkx/generators/line.py
+++ b/networkx/generators/line.py
@@ -10,7 +10,7 @@
 __all__ = ["line_graph", "inverse_line_graph"]
 
 
-@nx._dispatch
+@nx._dispatchable
 def line_graph(G, create_using=None):
     r"""Returns the line graph of the graph or digraph `G`.
 
@@ -215,7 +215,7 @@ def _lg_undirected(G, selfloops=False, create_using=None):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def inverse_line_graph(G):
     """Returns the inverse line graph of graph G.
 
diff --git a/networkx/generators/mycielski.py b/networkx/generators/mycielski.py
index 6e966d1fecb..492be58fd8e 100644
--- a/networkx/generators/mycielski.py
+++ b/networkx/generators/mycielski.py
@@ -11,7 +11,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def mycielskian(G, iterations=1):
     r"""Returns the Mycielskian of a simple, undirected graph G
 
@@ -68,7 +68,7 @@ def mycielskian(G, iterations=1):
     return M
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def mycielski_graph(n):
     """Generator for the n_th Mycielski Graph.
 
diff --git a/networkx/generators/nonisomorphic_trees.py b/networkx/generators/nonisomorphic_trees.py
index ae74b09c9cc..6f5d6412361 100644
--- a/networkx/generators/nonisomorphic_trees.py
+++ b/networkx/generators/nonisomorphic_trees.py
@@ -12,7 +12,7 @@
 import networkx as nx
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def nonisomorphic_trees(order, create="graph"):
     """Returns a list of nonisomorphic trees
 
@@ -52,7 +52,7 @@ def nonisomorphic_trees(order, create="graph"):
             layout = _next_rooted_tree(layout)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def number_of_nonisomorphic_trees(order):
     """Returns the number of nonisomorphic trees
 
diff --git a/networkx/generators/random_clustered.py b/networkx/generators/random_clustered.py
index 676346ab9df..abd7a8c9c6e 100644
--- a/networkx/generators/random_clustered.py
+++ b/networkx/generators/random_clustered.py
@@ -7,7 +7,7 @@
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_clustered_graph(joint_degree_sequence, create_using=None, seed=None):
     r"""Generate a random graph with the given joint independent edge degree and
     triangle degree sequence.
diff --git a/networkx/generators/random_graphs.py b/networkx/generators/random_graphs.py
index e08c4ce7d1f..dc65a962123 100644
--- a/networkx/generators/random_graphs.py
+++ b/networkx/generators/random_graphs.py
@@ -37,7 +37,7 @@
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def fast_gnp_random_graph(n, p, seed=None, directed=False):
     """Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or
     a binomial graph.
@@ -109,7 +109,7 @@ def fast_gnp_random_graph(n, p, seed=None, directed=False):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def gnp_random_graph(n, p, seed=None, directed=False):
     """Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph
     or a binomial graph.
@@ -174,7 +174,7 @@ def gnp_random_graph(n, p, seed=None, directed=False):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def dense_gnm_random_graph(n, m, seed=None):
     """Returns a $G_{n,m}$ random graph.
 
@@ -236,7 +236,7 @@ def dense_gnm_random_graph(n, m, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def gnm_random_graph(n, m, seed=None, directed=False):
     """Returns a $G_{n,m}$ random graph.
 
@@ -292,7 +292,7 @@ def gnm_random_graph(n, m, seed=None, directed=False):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def newman_watts_strogatz_graph(n, k, p, seed=None):
     """Returns a Newman–Watts–Strogatz small-world graph.
 
@@ -363,7 +363,7 @@ def newman_watts_strogatz_graph(n, k, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def watts_strogatz_graph(n, k, p, seed=None):
     """Returns a Watts–Strogatz small-world graph.
 
@@ -438,7 +438,7 @@ def watts_strogatz_graph(n, k, p, seed=None):
 
 
 @py_random_state(4)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def connected_watts_strogatz_graph(n, k, p, tries=100, seed=None):
     """Returns a connected Watts–Strogatz small-world graph.
 
@@ -491,7 +491,7 @@ def connected_watts_strogatz_graph(n, k, p, tries=100, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_regular_graph(d, n, seed=None):
     r"""Returns a random $d$-regular graph on $n$ nodes.
 
@@ -622,7 +622,7 @@ def _random_subset(seq, m, rng):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def barabasi_albert_graph(n, m, seed=None, initial_graph=None):
     """Returns a random graph using Barabási–Albert preferential attachment
 
@@ -695,7 +695,7 @@ def barabasi_albert_graph(n, m, seed=None, initial_graph=None):
 
 
 @py_random_state(4)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def dual_barabasi_albert_graph(n, m1, m2, p, seed=None, initial_graph=None):
     """Returns a random graph using dual Barabási–Albert preferential attachment
 
@@ -795,7 +795,7 @@ def dual_barabasi_albert_graph(n, m1, m2, p, seed=None, initial_graph=None):
 
 
 @py_random_state(4)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def extended_barabasi_albert_graph(n, m, p, q, seed=None):
     """Returns an extended Barabási–Albert model graph.
 
@@ -956,7 +956,7 @@ def extended_barabasi_albert_graph(n, m, p, q, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def powerlaw_cluster_graph(n, m, p, seed=None):
     """Holme and Kim algorithm for growing graphs with powerlaw
     degree distribution and approximate average clustering.
@@ -1046,7 +1046,7 @@ def powerlaw_cluster_graph(n, m, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_lobster(n, p1, p2, seed=None):
     """Returns a random lobster graph.
 
@@ -1097,7 +1097,7 @@ def random_lobster(n, p1, p2, seed=None):
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_shell_graph(constructor, seed=None):
     """Returns a random shell graph for the constructor given.
 
@@ -1155,7 +1155,7 @@ def random_shell_graph(constructor, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
     """Returns a tree with a power law degree distribution.
 
@@ -1192,7 +1192,7 @@ def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
 
 
 @py_random_state(2)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_powerlaw_tree_sequence(n, gamma=3, seed=None, tries=100):
     """Returns a degree sequence for a tree with a power law distribution.
 
@@ -1249,7 +1249,7 @@ def random_powerlaw_tree_sequence(n, gamma=3, seed=None, tries=100):
 
 
 @py_random_state(3)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_kernel_graph(n, kernel_integral, kernel_root=None, seed=None):
     r"""Returns an random graph based on the specified kernel.
 
diff --git a/networkx/generators/small.py b/networkx/generators/small.py
index 77109551c19..0efa62bc521 100644
--- a/networkx/generators/small.py
+++ b/networkx/generators/small.py
@@ -59,7 +59,7 @@ def wrapper(*args, **kwargs):
     return wrapper
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def LCF_graph(n, shift_list, repeats, create_using=None):
     """
     Return the cubic graph specified in LCF notation.
@@ -126,7 +126,7 @@ def LCF_graph(n, shift_list, repeats, create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def bull_graph(create_using=None):
     """
     Returns the Bull Graph
@@ -160,7 +160,7 @@ def bull_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def chvatal_graph(create_using=None):
     """
     Returns the Chvátal Graph
@@ -205,7 +205,7 @@ def chvatal_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def cubical_graph(create_using=None):
     """
     Returns the 3-regular Platonic Cubical Graph
@@ -248,7 +248,7 @@ def cubical_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def desargues_graph(create_using=None):
     """
     Returns the Desargues Graph
@@ -279,7 +279,7 @@ def desargues_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def diamond_graph(create_using=None):
     """
     Returns the Diamond graph
@@ -308,7 +308,7 @@ def diamond_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def dodecahedral_graph(create_using=None):
     """
     Returns the Platonic Dodecahedral graph.
@@ -339,7 +339,7 @@ def dodecahedral_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def frucht_graph(create_using=None):
     """
     Returns the Frucht Graph.
@@ -386,7 +386,7 @@ def frucht_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def heawood_graph(create_using=None):
     """
     Returns the Heawood Graph, a (3,6) cage.
@@ -420,7 +420,7 @@ def heawood_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def hoffman_singleton_graph():
     """
     Returns the Hoffman-Singleton Graph.
@@ -464,7 +464,7 @@ def hoffman_singleton_graph():
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def house_graph(create_using=None):
     """
     Returns the House graph (square with triangle on top)
@@ -495,7 +495,7 @@ def house_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def house_x_graph(create_using=None):
     """
     Returns the House graph with a cross inside the house square.
@@ -525,7 +525,7 @@ def house_x_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def icosahedral_graph(create_using=None):
     """
     Returns the Platonic Icosahedral graph.
@@ -568,7 +568,7 @@ def icosahedral_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def krackhardt_kite_graph(create_using=None):
     """
     Returns the Krackhardt Kite Social Network.
@@ -618,7 +618,7 @@ def krackhardt_kite_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def moebius_kantor_graph(create_using=None):
     """
     Returns the Moebius-Kantor graph.
@@ -648,7 +648,7 @@ def moebius_kantor_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def octahedral_graph(create_using=None):
     """
     Returns the Platonic Octahedral graph.
@@ -683,7 +683,7 @@ def octahedral_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def pappus_graph():
     """
     Returns the Pappus graph.
@@ -707,7 +707,7 @@ def pappus_graph():
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def petersen_graph(create_using=None):
     """
     Returns the Petersen graph.
@@ -751,7 +751,7 @@ def petersen_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def sedgewick_maze_graph(create_using=None):
     """
     Return a small maze with a cycle.
@@ -784,7 +784,7 @@ def sedgewick_maze_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def tetrahedral_graph(create_using=None):
     """
     Returns the 3-regular Platonic Tetrahedral graph.
@@ -814,7 +814,7 @@ def tetrahedral_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def truncated_cube_graph(create_using=None):
     """
     Returns the skeleton of the truncated cube.
@@ -872,7 +872,7 @@ def truncated_cube_graph(create_using=None):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def truncated_tetrahedron_graph(create_using=None):
     """
     Returns the skeleton of the truncated Platonic tetrahedron.
@@ -903,7 +903,7 @@ def truncated_tetrahedron_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def tutte_graph(create_using=None):
     """
     Returns the Tutte graph.
diff --git a/networkx/generators/social.py b/networkx/generators/social.py
index 5391c834acf..5d950649c3e 100644
--- a/networkx/generators/social.py
+++ b/networkx/generators/social.py
@@ -11,7 +11,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def karate_club_graph():
     """Returns Zachary's Karate Club graph.
 
@@ -93,7 +93,7 @@ def karate_club_graph():
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def davis_southern_women_graph():
     """Returns Davis Southern women social network.
 
@@ -244,7 +244,7 @@ def davis_southern_women_graph():
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def florentine_families_graph():
     """Returns Florentine families graph.
 
@@ -278,7 +278,7 @@ def florentine_families_graph():
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def les_miserables_graph():
     """Returns coappearance network of characters in the novel Les Miserables.
 
diff --git a/networkx/generators/spectral_graph_forge.py b/networkx/generators/spectral_graph_forge.py
index 0371b68f59b..cdd1250fa18 100644
--- a/networkx/generators/spectral_graph_forge.py
+++ b/networkx/generators/spectral_graph_forge.py
@@ -8,7 +8,7 @@
 
 
 @np_random_state(3)
-@nx._dispatch
+@nx._dispatchable
 def spectral_graph_forge(G, alpha, transformation="identity", seed=None):
     """Returns a random simple graph with spectrum resembling that of `G`
 
diff --git a/networkx/generators/stochastic.py b/networkx/generators/stochastic.py
index b8084532bc3..75d9c0b25b3 100644
--- a/networkx/generators/stochastic.py
+++ b/networkx/generators/stochastic.py
@@ -11,7 +11,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def stochastic_graph(G, copy=True, weight="weight"):
     """Returns a right-stochastic representation of directed graph `G`.
 
diff --git a/networkx/generators/sudoku.py b/networkx/generators/sudoku.py
index bc91505b179..c8ac57c48c0 100644
--- a/networkx/generators/sudoku.py
+++ b/networkx/generators/sudoku.py
@@ -47,7 +47,7 @@
 __all__ = ["sudoku_graph"]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def sudoku_graph(n=3):
     """Returns the n-Sudoku graph. The default value of n is 3.
 
diff --git a/networkx/generators/time_series.py b/networkx/generators/time_series.py
index 7373f8edc38..ac060627bac 100644
--- a/networkx/generators/time_series.py
+++ b/networkx/generators/time_series.py
@@ -8,7 +8,7 @@
 __all__ = ["visibility_graph"]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def visibility_graph(series):
     """
     Return a Visibility Graph of an input Time Series.
diff --git a/networkx/generators/trees.py b/networkx/generators/trees.py
index a24f8994c5f..60c2fc640e3 100644
--- a/networkx/generators/trees.py
+++ b/networkx/generators/trees.py
@@ -48,7 +48,7 @@
 ]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def prefix_tree(paths):
     """Creates a directed prefix tree from a list of paths.
 
@@ -181,7 +181,7 @@ def get_children(parent, paths):
     return tree
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def prefix_tree_recursive(paths):
     """Recursively creates a directed prefix tree from a list of paths.
 
@@ -324,7 +324,7 @@ def _helper(paths, root, tree):
 
 
 @py_random_state(1)
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_tree(n, seed=None, create_using=None):
     """Returns a uniformly random tree on `n` nodes.
 
@@ -426,7 +426,7 @@ def random_tree(n, seed=None, create_using=None):
 
 
 @py_random_state("seed")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_labeled_tree(n, *, seed=None):
     """Returns a labeled tree on `n` nodes chosen uniformly at random.
 
@@ -462,7 +462,7 @@ def random_labeled_tree(n, *, seed=None):
 
 
 @py_random_state("seed")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_labeled_rooted_tree(n, *, seed=None):
     """Returns a labeled rooted tree with `n` nodes.
 
@@ -499,7 +499,7 @@ def random_labeled_rooted_tree(n, *, seed=None):
 
 
 @py_random_state("seed")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_labeled_rooted_forest(n, *, seed=None):
     """Returns a labeled rooted forest with `n` nodes.
 
@@ -737,7 +737,7 @@ def _random_unlabeled_rooted_tree(n, cache_trees, seed):
 
 
 @py_random_state("seed")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_unlabeled_rooted_tree(n, *, number_of_trees=None, seed=None):
     """Returns a number of unlabeled rooted trees uniformly at random
 
@@ -922,7 +922,7 @@ def _random_unlabeled_rooted_forest(n, q, cache_trees, cache_forests, seed):
 
 
 @py_random_state("seed")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_unlabeled_rooted_forest(n, *, q=None, number_of_forests=None, seed=None):
     """Returns a forest or list of forests selected at random.
 
@@ -1099,7 +1099,7 @@ def _random_unlabeled_tree(n, cache_trees, cache_forests, seed):
 
 
 @py_random_state("seed")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def random_unlabeled_tree(n, *, number_of_trees=None, seed=None):
     """Returns a tree or list of trees chosen randomly.
 
diff --git a/networkx/generators/triads.py b/networkx/generators/triads.py
index 86d522bba4a..40b0f82a210 100644
--- a/networkx/generators/triads.py
+++ b/networkx/generators/triads.py
@@ -33,7 +33,7 @@
 }
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def triad_graph(triad_name):
     """Returns the triad graph with the given name.
 
diff --git a/networkx/linalg/algebraicconnectivity.py b/networkx/linalg/algebraicconnectivity.py
index b70d204a84d..70f23bbac97 100644
--- a/networkx/linalg/algebraicconnectivity.py
+++ b/networkx/linalg/algebraicconnectivity.py
@@ -312,7 +312,7 @@ def find_fiedler(L, x, normalized, tol, seed):
 
 @not_implemented_for("directed")
 @np_random_state(5)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def algebraic_connectivity(
     G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
 ):
@@ -408,7 +408,7 @@ def algebraic_connectivity(
 
 @not_implemented_for("directed")
 @np_random_state(5)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def fiedler_vector(
     G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
 ):
@@ -505,7 +505,7 @@ def fiedler_vector(
 
 
 @np_random_state(5)
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def spectral_ordering(
     G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
 ):
@@ -588,7 +588,7 @@ def spectral_ordering(
     return order
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def spectral_bisection(
     G, weight="weight", normalized=False, tol=1e-8, method="tracemin_pcg", seed=None
 ):
diff --git a/networkx/linalg/attrmatrix.py b/networkx/linalg/attrmatrix.py
index eb6e57c857c..4882c35af4b 100644
--- a/networkx/linalg/attrmatrix.py
+++ b/networkx/linalg/attrmatrix.py
@@ -142,7 +142,7 @@ def value(u, v):
     return value
 
 
-@nx._dispatch(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
+@nx._dispatchable(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
 def attr_matrix(
     G,
     edge_attr=None,
@@ -306,7 +306,7 @@ def attr_matrix(
         return M
 
 
-@nx._dispatch(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
+@nx._dispatchable(edge_attrs={"edge_attr": None}, node_attrs="node_attr")
 def attr_sparse_matrix(
     G, edge_attr=None, node_attr=None, normalized=False, rc_order=None, dtype=None
 ):
diff --git a/networkx/linalg/bethehessianmatrix.py b/networkx/linalg/bethehessianmatrix.py
index 542fd1c6712..382e5181047 100644
--- a/networkx/linalg/bethehessianmatrix.py
+++ b/networkx/linalg/bethehessianmatrix.py
@@ -7,7 +7,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch
+@nx._dispatchable
 def bethe_hessian_matrix(G, r=None, nodelist=None):
     r"""Returns the Bethe Hessian matrix of G.
 
diff --git a/networkx/linalg/graphmatrix.py b/networkx/linalg/graphmatrix.py
index 9dece36b48c..640fccc6e2e 100644
--- a/networkx/linalg/graphmatrix.py
+++ b/networkx/linalg/graphmatrix.py
@@ -6,7 +6,7 @@
 __all__ = ["incidence_matrix", "adjacency_matrix"]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def incidence_matrix(
     G, nodelist=None, edgelist=None, oriented=False, weight=None, *, dtype=None
 ):
@@ -104,7 +104,7 @@ def incidence_matrix(
     return A.asformat("csc")
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def adjacency_matrix(G, nodelist=None, dtype=None, weight="weight"):
     """Returns adjacency matrix of G.
 
diff --git a/networkx/linalg/laplacianmatrix.py b/networkx/linalg/laplacianmatrix.py
index bd9e1d3c45f..73ce45e4ce4 100644
--- a/networkx/linalg/laplacianmatrix.py
+++ b/networkx/linalg/laplacianmatrix.py
@@ -19,7 +19,7 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def laplacian_matrix(G, nodelist=None, weight="weight"):
     """Returns the Laplacian matrix of G.
 
@@ -108,7 +108,7 @@ def laplacian_matrix(G, nodelist=None, weight="weight"):
     return D - A
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     r"""Returns the normalized Laplacian matrix of G.
 
@@ -207,7 +207,7 @@ def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     return DH @ (L @ DH)
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def total_spanning_tree_weight(G, weight=None):
     """
     Returns the total weight of all spanning trees of `G`.
@@ -246,7 +246,7 @@ def total_spanning_tree_weight(G, weight=None):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def directed_laplacian_matrix(
     G, nodelist=None, weight="weight", walk_type=None, alpha=0.95
 ):
@@ -345,7 +345,7 @@ def directed_laplacian_matrix(
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def directed_combinatorial_laplacian_matrix(
     G, nodelist=None, weight="weight", walk_type=None, alpha=0.95
 ):
diff --git a/networkx/linalg/modularitymatrix.py b/networkx/linalg/modularitymatrix.py
index 03671a1fa10..fc599b35393 100644
--- a/networkx/linalg/modularitymatrix.py
+++ b/networkx/linalg/modularitymatrix.py
@@ -8,7 +8,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def modularity_matrix(G, nodelist=None, weight=None):
     r"""Returns the modularity matrix of G.
 
@@ -77,7 +77,7 @@ def modularity_matrix(G, nodelist=None, weight=None):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def directed_modularity_matrix(G, nodelist=None, weight=None):
     """Returns the directed modularity matrix of G.
 
diff --git a/networkx/linalg/spectrum.py b/networkx/linalg/spectrum.py
index 979eeabd814..16dfa148c30 100644
--- a/networkx/linalg/spectrum.py
+++ b/networkx/linalg/spectrum.py
@@ -12,7 +12,7 @@
 ]
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def laplacian_spectrum(G, weight="weight"):
     """Returns eigenvalues of the Laplacian of G
 
@@ -56,7 +56,7 @@ def laplacian_spectrum(G, weight="weight"):
     return sp.linalg.eigvalsh(nx.laplacian_matrix(G, weight=weight).todense())
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def normalized_laplacian_spectrum(G, weight="weight"):
     """Return eigenvalues of the normalized Laplacian of G
 
@@ -90,7 +90,7 @@ def normalized_laplacian_spectrum(G, weight="weight"):
     )
 
 
-@nx._dispatch(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight")
 def adjacency_spectrum(G, weight="weight"):
     """Returns eigenvalues of the adjacency matrix of G.
 
@@ -122,7 +122,7 @@ def adjacency_spectrum(G, weight="weight"):
     return sp.linalg.eigvals(nx.adjacency_matrix(G, weight=weight).todense())
 
 
-@nx._dispatch
+@nx._dispatchable
 def modularity_spectrum(G):
     """Returns eigenvalues of the modularity matrix of G.
 
@@ -153,7 +153,7 @@ def modularity_spectrum(G):
         return sp.linalg.eigvals(nx.modularity_matrix(G))
 
 
-@nx._dispatch
+@nx._dispatchable
 def bethe_hessian_spectrum(G, r=None):
     """Returns eigenvalues of the Bethe Hessian matrix of G.
 
diff --git a/networkx/readwrite/adjlist.py b/networkx/readwrite/adjlist.py
index 243550bde2d..a14ad430086 100644
--- a/networkx/readwrite/adjlist.py
+++ b/networkx/readwrite/adjlist.py
@@ -150,7 +150,7 @@ def write_adjlist(G, path, comments="#", delimiter=" ", encoding="utf-8"):
         path.write(line.encode(encoding))
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_adjlist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None
 ):
@@ -224,7 +224,7 @@ def parse_adjlist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_adjlist(
     path,
     comments="#",
diff --git a/networkx/readwrite/edgelist.py b/networkx/readwrite/edgelist.py
index 733b544326c..fcf6ec23013 100644
--- a/networkx/readwrite/edgelist.py
+++ b/networkx/readwrite/edgelist.py
@@ -173,7 +173,7 @@ def write_edgelist(G, path, comments="#", delimiter=" ", data=True, encoding="ut
         path.write(line.encode(encoding))
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_edgelist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
 ):
@@ -298,7 +298,7 @@ def parse_edgelist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_edgelist(
     path,
     comments="#",
@@ -425,7 +425,7 @@ def write_weighted_edgelist(G, path, comments="#", delimiter=" ", encoding="utf-
     )
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_weighted_edgelist(
     path,
     comments="#",
diff --git a/networkx/readwrite/gexf.py b/networkx/readwrite/gexf.py
index 35be5568fc2..de444c5b31a 100644
--- a/networkx/readwrite/gexf.py
+++ b/networkx/readwrite/gexf.py
@@ -133,7 +133,7 @@ def generate_gexf(G, encoding="utf-8", prettyprint=True, version="1.2draft"):
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_gexf(path, node_type=None, relabel=False, version="1.2draft"):
     """Read graph in GEXF format from path.
 
diff --git a/networkx/readwrite/gml.py b/networkx/readwrite/gml.py
index f04c28232ae..f76fc204203 100644
--- a/networkx/readwrite/gml.py
+++ b/networkx/readwrite/gml.py
@@ -112,7 +112,7 @@ def literal_destringizer(rep):
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_gml(path, label="label", destringizer=None):
     """Read graph in GML format from `path`.
 
@@ -195,7 +195,7 @@ def filter_lines(lines):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_gml(lines, label="label", destringizer=None):
     """Parse GML graph from a string or iterable.
 
diff --git a/networkx/readwrite/graph6.py b/networkx/readwrite/graph6.py
index ab462b69b85..06578e05ed6 100644
--- a/networkx/readwrite/graph6.py
+++ b/networkx/readwrite/graph6.py
@@ -60,7 +60,7 @@ def _generate_graph6_bytes(G, nodes, header):
     yield b"\n"
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_graph6_bytes(bytes_in):
     """Read a simple undirected graph in graph6 format from bytes.
 
@@ -184,7 +184,7 @@ def to_graph6_bytes(G, nodes=None, header=True):
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_graph6(path):
     """Read simple undirected graphs in graph6 format from path.
 
diff --git a/networkx/readwrite/graphml.py b/networkx/readwrite/graphml.py
index d18c0e8dde9..4de6ca1e882 100644
--- a/networkx/readwrite/graphml.py
+++ b/networkx/readwrite/graphml.py
@@ -233,7 +233,7 @@ def generate_graphml(
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_graphml(path, node_type=str, edge_key_type=int, force_multigraph=False):
     """Read graph in GraphML format from path.
 
@@ -306,7 +306,7 @@ def read_graphml(path, node_type=str, edge_key_type=int, force_multigraph=False)
     return glist[0]
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_graphml(
     graphml_string, node_type=str, edge_key_type=int, force_multigraph=False
 ):
diff --git a/networkx/readwrite/json_graph/adjacency.py b/networkx/readwrite/json_graph/adjacency.py
index 75695d3dff5..8fb24ea031b 100644
--- a/networkx/readwrite/json_graph/adjacency.py
+++ b/networkx/readwrite/json_graph/adjacency.py
@@ -81,7 +81,7 @@ def adjacency_data(G, attrs=_attrs):
     return data
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def adjacency_graph(data, directed=False, multigraph=True, attrs=_attrs):
     """Returns graph from adjacency data format.
 
diff --git a/networkx/readwrite/json_graph/cytoscape.py b/networkx/readwrite/json_graph/cytoscape.py
index 7689192d471..306c4b4f418 100644
--- a/networkx/readwrite/json_graph/cytoscape.py
+++ b/networkx/readwrite/json_graph/cytoscape.py
@@ -80,7 +80,7 @@ def cytoscape_data(G, name="name", ident="id"):
     return jsondata
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def cytoscape_graph(data, name="name", ident="id"):
     """
     Create a NetworkX graph from a dictionary in cytoscape JSON format.
diff --git a/networkx/readwrite/json_graph/node_link.py b/networkx/readwrite/json_graph/node_link.py
index 4a2e8c6d486..a9fbb29b2ad 100644
--- a/networkx/readwrite/json_graph/node_link.py
+++ b/networkx/readwrite/json_graph/node_link.py
@@ -132,7 +132,7 @@ def node_link_data(
     return data
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def node_link_graph(
     data,
     directed=False,
diff --git a/networkx/readwrite/json_graph/tree.py b/networkx/readwrite/json_graph/tree.py
index c0b3af18378..bd8679fcab1 100644
--- a/networkx/readwrite/json_graph/tree.py
+++ b/networkx/readwrite/json_graph/tree.py
@@ -83,7 +83,7 @@ def add_children(n, G):
     return {**G.nodes[root], ident: root, children: add_children(root, G)}
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def tree_graph(data, ident="id", children="children"):
     """Returns graph from tree data format.
 
diff --git a/networkx/readwrite/leda.py b/networkx/readwrite/leda.py
index 735f2779b4a..d07162b65f3 100644
--- a/networkx/readwrite/leda.py
+++ b/networkx/readwrite/leda.py
@@ -19,7 +19,7 @@
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_leda(path, encoding="UTF-8"):
     """Read graph in LEDA format from path.
 
@@ -46,7 +46,7 @@ def read_leda(path, encoding="UTF-8"):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_leda(lines):
     """Read graph in LEDA format from string or iterable.
 
diff --git a/networkx/readwrite/multiline_adjlist.py b/networkx/readwrite/multiline_adjlist.py
index d4156ee3f33..fe542e6a1fd 100644
--- a/networkx/readwrite/multiline_adjlist.py
+++ b/networkx/readwrite/multiline_adjlist.py
@@ -191,7 +191,7 @@ def write_multiline_adjlist(G, path, delimiter=" ", comments="#", encoding="utf-
         path.write(multiline.encode(encoding))
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_multiline_adjlist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None, edgetype=None
 ):
@@ -301,7 +301,7 @@ def parse_multiline_adjlist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_multiline_adjlist(
     path,
     comments="#",
diff --git a/networkx/readwrite/p2g.py b/networkx/readwrite/p2g.py
index 84c72572e91..2afba8c6f4d 100644
--- a/networkx/readwrite/p2g.py
+++ b/networkx/readwrite/p2g.py
@@ -57,7 +57,7 @@ def write_p2g(G, path, encoding="utf-8"):
 
 
 @open_file(0, mode="r")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_p2g(path, encoding="utf-8"):
     """Read graph in p2g format from path.
 
@@ -75,7 +75,7 @@ def read_p2g(path, encoding="utf-8"):
     return G
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_p2g(lines):
     """Parse p2g format graph from string or iterable.
 
diff --git a/networkx/readwrite/pajek.py b/networkx/readwrite/pajek.py
index 0c6050f1507..fef19408001 100644
--- a/networkx/readwrite/pajek.py
+++ b/networkx/readwrite/pajek.py
@@ -130,7 +130,7 @@ def write_pajek(G, path, encoding="UTF-8"):
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_pajek(path, encoding="UTF-8"):
     """Read graph in Pajek format from path.
 
@@ -163,7 +163,7 @@ def read_pajek(path, encoding="UTF-8"):
     return parse_pajek(lines)
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def parse_pajek(lines):
     """Parse Pajek format graph from string or iterable.
 
diff --git a/networkx/readwrite/sparse6.py b/networkx/readwrite/sparse6.py
index 054f1a0d14c..04fe9e6edc6 100644
--- a/networkx/readwrite/sparse6.py
+++ b/networkx/readwrite/sparse6.py
@@ -101,7 +101,7 @@ def enc(x):
     yield b"\n"
 
 
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def from_sparse6_bytes(string):
     """Read an undirected graph in sparse6 format from string.
 
@@ -250,7 +250,7 @@ def to_sparse6_bytes(G, nodes=None, header=True):
 
 
 @open_file(0, mode="rb")
-@nx._dispatch(graphs=None)
+@nx._dispatchable(graphs=None)
 def read_sparse6(path):
     """Read an undirected graph in sparse6 format from path.
 
diff --git a/networkx/relabel.py b/networkx/relabel.py
index f55695bdfe9..93a404921f9 100644
--- a/networkx/relabel.py
+++ b/networkx/relabel.py
@@ -3,7 +3,7 @@
 __all__ = ["convert_node_labels_to_integers", "relabel_nodes"]
 
 
-@nx._dispatch(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True)
 def relabel_nodes(G, mapping, copy=True):
     """Relabel the nodes of the graph G according to a given mapping.
 
@@ -221,7 +221,7 @@ def _relabel_copy(G, mapping):
     return H
 
 
-@nx._dispatch(
+@nx._dispatchable(
     preserve_edge_attrs=True, preserve_node_attrs=True, preserve_graph_attrs=True
 )
 def convert_node_labels_to_integers(
diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 6c0e5649bd3..26cec6d2d83 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -95,7 +95,7 @@ class WrappedSparse:
 
 from ..exception import NetworkXNotImplemented
 
-__all__ = ["_dispatch"]
+__all__ = ["_dispatchable"]
 
 
 def _get_backends(group, *, load_and_call=False):
@@ -141,14 +141,14 @@ def _load_backend(backend_name):
 _registered_algorithms = {}
 
 
-class _dispatch:
+class _dispatchable:
     # Allow any of the following decorator forms:
-    #  - @_dispatch
-    #  - @_dispatch()
-    #  - @_dispatch(name="override_name")
-    #  - @_dispatch(graphs="graph")
-    #  - @_dispatch(edge_attrs="weight")
-    #  - @_dispatch(graphs={"G": 0, "H": 1}, edge_attrs={"weight": "default"})
+    #  - @_dispatchable
+    #  - @_dispatchable()
+    #  - @_dispatchable(name="override_name")
+    #  - @_dispatchable(graphs="graph")
+    #  - @_dispatchable(edge_attrs="weight")
+    #  - @_dispatchable(graphs={"G": 0, "H": 1}, edge_attrs={"weight": "default"})
 
     # These class attributes are currently used to allow backends to run networkx tests.
     # For example: `PYTHONPATH=. pytest --backend graphblas --fallback-to-nx`
@@ -192,7 +192,7 @@ def __new__(
             argument of the wrapped function. If more than one graph is required
             for the algorithm (or if the graph is not the first argument), provide
             a dict of parameter name to argument position for each graph argument.
-            For example, ``@_dispatch(graphs={"G": 0, "auxiliary?": 4})``
+            For example, ``@_dispatchable(graphs={"G": 0, "auxiliary?": 4})``
             indicates the 0th parameter ``G`` of the function is a required graph,
             and the 4th parameter ``auxiliary`` is an optional graph.
             To indicate an argument is a list of graphs, do e.g. ``"[graphs]"``.
@@ -235,7 +235,7 @@ def __new__(
         """
         if func is None:
             return partial(
-                _dispatch,
+                _dispatchable,
                 name=name,
                 graphs=graphs,
                 edge_attrs=edge_attrs,
@@ -990,10 +990,10 @@ def __reduce__(self):
 
         This uses the global registry `_registered_algorithms` to deserialize.
         """
-        return _restore_dispatch, (self.name,)
+        return _restore_dispatchable, (self.name,)
 
 
-def _restore_dispatch(name):
+def _restore_dispatchable(name):
     return _registered_algorithms[name]
 
 
@@ -1003,17 +1003,17 @@ def _restore_dispatch(name):
     # This doesn't show e.g. `*, backend=None, **backend_kwargs` in the
     # signatures, which is probably okay. It does allow the docstring to be
     # updated based on the installed backends.
-    _orig_dispatch = _dispatch
+    _orig_dispatchable = _dispatchable
 
-    def _dispatch(func=None, **kwargs):  # type: ignore[no-redef]
+    def _dispatchable(func=None, **kwargs):  # type: ignore[no-redef]
         if func is None:
-            return partial(_dispatch, **kwargs)
-        dispatched_func = _orig_dispatch(func, **kwargs)
+            return partial(_dispatchable, **kwargs)
+        dispatched_func = _orig_dispatchable(func, **kwargs)
         func.__doc__ = dispatched_func.__doc__
         return func
 
-    _dispatch.__doc__ = _orig_dispatch.__new__.__doc__  # type: ignore[method-assign,assignment]
-    _sig = inspect.signature(_orig_dispatch.__new__)
-    _dispatch.__signature__ = _sig.replace(  # type: ignore[method-assign,assignment]
+    _dispatchable.__doc__ = _orig_dispatchable.__new__.__doc__  # type: ignore[method-assign,assignment]
+    _sig = inspect.signature(_orig_dispatchable.__new__)
+    _dispatchable.__signature__ = _sig.replace(  # type: ignore[method-assign,assignment]
         parameters=[v for k, v in _sig.parameters.items() if k != "cls"]
     )

From e35e98b7fa512aef56243b548a9d078362359764 Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Fri, 12 Jan 2024 19:36:16 +0400
Subject: [PATCH 039/129] DOC: build with nx-parallel extra documentation
 information (#7220)

* DOC: build with nx-parallel extra documentation information

* also add it to circleci config
---
 .circleci/config.yml              | 2 ++
 .github/workflows/deploy-docs.yml | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index b7dfef39c00..b9277b86471 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -44,6 +44,8 @@ jobs:
             pip install git+https://github.com/rapidsai/cugraph.git#subdirectory=python/nx-cugraph --no-deps
             # Development version of GraphBLAS backend
             pip install git+https://github.com/python-graphblas/graphblas-algorithms.git@main --no-deps
+            # Development version of nx-parallel backend
+            pip install git+https://github.com/networkx/nx-parallel.git@main --no-deps
             pip list
 
       - save_cache:
diff --git a/.github/workflows/deploy-docs.yml b/.github/workflows/deploy-docs.yml
index 1bc885907b3..a45e6255bd2 100644
--- a/.github/workflows/deploy-docs.yml
+++ b/.github/workflows/deploy-docs.yml
@@ -38,6 +38,8 @@ jobs:
           pip install git+https://github.com/rapidsai/cugraph.git#subdirectory=python/nx-cugraph --no-deps
           # Development version of GraphBLAS backend
           pip install git+https://github.com/python-graphblas/graphblas-algorithms.git@main --no-deps
+          # Development version of nx-parallel backend
+          pip install git+https://github.com/networkx/nx-parallel.git@main --no-deps
           pip list
 
       # To set up a cross-repository deploy key:

From fd3cadc48c7277d12f2a27a03b2acb7b9783f783 Mon Sep 17 00:00:00 2001
From: Jangwon Yie <kleinaberoho10@gmail.com>
Date: Fri, 12 Jan 2024 21:36:52 -0500
Subject: [PATCH 040/129] Add functions to compute Schultz and Gutman Index
 (#3709)

* Add implementaions of Schultz index of first, second kind and their unit tests

* Add schultz.rst and update __init__.py

* remove an ambiguous variable

* move new functions to wiener.py clean up references and docs

* Minor docstring touchups.

---------

Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@caltech.edu>
---
 doc/reference/algorithms/wiener.rst      |   4 +-
 networkx/algorithms/__init__.py          |   2 +-
 networkx/algorithms/tests/test_wiener.py | 189 +++++++++++++++--------
 networkx/algorithms/wiener.py            | 189 ++++++++++++++++++++---
 4 files changed, 294 insertions(+), 90 deletions(-)

diff --git a/doc/reference/algorithms/wiener.rst b/doc/reference/algorithms/wiener.rst
index c0ac446adb8..acd070a99aa 100644
--- a/doc/reference/algorithms/wiener.rst
+++ b/doc/reference/algorithms/wiener.rst
@@ -1,5 +1,5 @@
 ************
-Wiener index
+Wiener Index
 ************
 
 .. automodule:: networkx.algorithms.wiener
@@ -7,3 +7,5 @@ Wiener index
    :toctree: generated/
 
    wiener_index
+   schultz_index
+   gutman_index
diff --git a/networkx/algorithms/__init__.py b/networkx/algorithms/__init__.py
index db6d6cebb19..eda2912cadd 100644
--- a/networkx/algorithms/__init__.py
+++ b/networkx/algorithms/__init__.py
@@ -37,6 +37,7 @@
 from networkx.algorithms.operators import *
 from networkx.algorithms.planarity import *
 from networkx.algorithms.planar_drawing import *
+from networkx.algorithms.polynomials import *
 from networkx.algorithms.reciprocity import *
 from networkx.algorithms.regular import *
 from networkx.algorithms.richclub import *
@@ -57,7 +58,6 @@
 from networkx.algorithms.voronoi import *
 from networkx.algorithms.walks import *
 from networkx.algorithms.wiener import *
-from networkx.algorithms.polynomials import *
 
 # Make certain subpackages available to the user as direct imports from
 # the `networkx` namespace.
diff --git a/networkx/algorithms/tests/test_wiener.py b/networkx/algorithms/tests/test_wiener.py
index 1cb404064fe..aded95143ca 100644
--- a/networkx/algorithms/tests/test_wiener.py
+++ b/networkx/algorithms/tests/test_wiener.py
@@ -1,66 +1,123 @@
-"""Unit tests for the :mod:`networkx.algorithms.wiener` module."""
-
-
-from networkx import DiGraph, complete_graph, empty_graph, path_graph, wiener_index
-
-
-class TestWienerIndex:
-    """Unit tests for computing the Wiener index of a graph."""
-
-    def test_disconnected_graph(self):
-        """Tests that the Wiener index of a disconnected graph is
-        positive infinity.
-
-        """
-        assert wiener_index(empty_graph(2)) == float("inf")
-
-    def test_directed(self):
-        """Tests that each pair of nodes in the directed graph is
-        counted once when computing the Wiener index.
-
-        """
-        G = complete_graph(3)
-        H = DiGraph(G)
-        assert (2 * wiener_index(G)) == wiener_index(H)
-
-    def test_complete_graph(self):
-        """Tests that the Wiener index of the complete graph is simply
-        the number of edges.
-
-        """
-        n = 10
-        G = complete_graph(n)
-        assert wiener_index(G) == (n * (n - 1) / 2)
-
-    def test_path_graph(self):
-        """Tests that the Wiener index of the path graph is correctly
-        computed.
-
-        """
-        # In P_n, there are n - 1 pairs of vertices at distance one, n -
-        # 2 pairs at distance two, n - 3 at distance three, ..., 1 at
-        # distance n - 1, so the Wiener index should be
-        #
-        #     1 * (n - 1) + 2 * (n - 2) + ... + (n - 2) * 2 + (n - 1) * 1
-        #
-        # For example, in P_5,
-        #
-        #     1 * 4 + 2 * 3 + 3 * 2 + 4 * 1 = 2 (1 * 4 + 2 * 3)
-        #
-        # and in P_6,
-        #
-        #     1 * 5 + 2 * 4 + 3 * 3 + 4 * 2 + 5 * 1 = 2 (1 * 5 + 2 * 4) + 3 * 3
-        #
-        # assuming n is *odd*, this gives the formula
-        #
-        #     2 \sum_{i = 1}^{(n - 1) / 2} [i * (n - i)]
-        #
-        # assuming n is *even*, this gives the formula
-        #
-        #     2 \sum_{i = 1}^{n / 2} [i * (n - i)] - (n / 2) ** 2
-        #
-        n = 9
-        G = path_graph(n)
-        expected = 2 * sum(i * (n - i) for i in range(1, (n // 2) + 1))
-        actual = wiener_index(G)
-        assert expected == actual
+import networkx as nx
+
+
+def test_wiener_index_of_disconnected_graph():
+    assert nx.wiener_index(nx.empty_graph(2)) == float("inf")
+
+
+def test_wiener_index_of_directed_graph():
+    G = nx.complete_graph(3)
+    H = nx.DiGraph(G)
+    assert (2 * nx.wiener_index(G)) == nx.wiener_index(H)
+
+
+def test_wiener_index_of_complete_graph():
+    n = 10
+    G = nx.complete_graph(n)
+    assert nx.wiener_index(G) == (n * (n - 1) / 2)
+
+
+def test_wiener_index_of_path_graph():
+    # In P_n, there are n - 1 pairs of vertices at distance one, n -
+    # 2 pairs at distance two, n - 3 at distance three, ..., 1 at
+    # distance n - 1, so the Wiener index should be
+    #
+    #     1 * (n - 1) + 2 * (n - 2) + ... + (n - 2) * 2 + (n - 1) * 1
+    #
+    # For example, in P_5,
+    #
+    #     1 * 4 + 2 * 3 + 3 * 2 + 4 * 1 = 2 (1 * 4 + 2 * 3)
+    #
+    # and in P_6,
+    #
+    #     1 * 5 + 2 * 4 + 3 * 3 + 4 * 2 + 5 * 1 = 2 (1 * 5 + 2 * 4) + 3 * 3
+    #
+    # assuming n is *odd*, this gives the formula
+    #
+    #     2 \sum_{i = 1}^{(n - 1) / 2} [i * (n - i)]
+    #
+    # assuming n is *even*, this gives the formula
+    #
+    #     2 \sum_{i = 1}^{n / 2} [i * (n - i)] - (n / 2) ** 2
+    #
+    n = 9
+    G = nx.path_graph(n)
+    expected = 2 * sum(i * (n - i) for i in range(1, (n // 2) + 1))
+    actual = nx.wiener_index(G)
+    assert expected == actual
+
+
+def test_schultz_and_gutman_index_of_disconnected_graph():
+    n = 4
+    G = nx.Graph()
+    G.add_nodes_from(list(range(1, n + 1)))
+    expected = float("inf")
+
+    G.add_edge(1, 2)
+    G.add_edge(3, 4)
+
+    actual_1 = nx.schultz_index(G)
+    actual_2 = nx.gutman_index(G)
+
+    assert expected == actual_1
+    assert expected == actual_2
+
+
+def test_schultz_and_gutman_index_of_complete_bipartite_graph_1():
+    n = 3
+    m = 3
+    cbg = nx.complete_bipartite_graph(n, m)
+
+    expected_1 = n * m * (n + m) + 2 * n * (n - 1) * m + 2 * m * (m - 1) * n
+    actual_1 = nx.schultz_index(cbg)
+
+    expected_2 = n * m * (n * m) + n * (n - 1) * m * m + m * (m - 1) * n * n
+    actual_2 = nx.gutman_index(cbg)
+
+    assert expected_1 == actual_1
+    assert expected_2 == actual_2
+
+
+def test_schultz_and_gutman_index_of_complete_bipartite_graph_2():
+    n = 2
+    m = 5
+    cbg = nx.complete_bipartite_graph(n, m)
+
+    expected_1 = n * m * (n + m) + 2 * n * (n - 1) * m + 2 * m * (m - 1) * n
+    actual_1 = nx.schultz_index(cbg)
+
+    expected_2 = n * m * (n * m) + n * (n - 1) * m * m + m * (m - 1) * n * n
+    actual_2 = nx.gutman_index(cbg)
+
+    assert expected_1 == actual_1
+    assert expected_2 == actual_2
+
+
+def test_schultz_and_gutman_index_of_complete_graph():
+    n = 5
+    cg = nx.complete_graph(n)
+
+    expected_1 = n * (n - 1) * (n - 1)
+    actual_1 = nx.schultz_index(cg)
+
+    assert expected_1 == actual_1
+
+    expected_2 = n * (n - 1) * (n - 1) * (n - 1) / 2
+    actual_2 = nx.gutman_index(cg)
+
+    assert expected_2 == actual_2
+
+
+def test_schultz_and_gutman_index_of_odd_cycle_graph():
+    k = 5
+    n = 2 * k + 1
+    ocg = nx.cycle_graph(n)
+
+    expected_1 = 2 * n * k * (k + 1)
+    actual_1 = nx.schultz_index(ocg)
+
+    expected_2 = 2 * n * k * (k + 1)
+    actual_2 = nx.gutman_index(ocg)
+
+    assert expected_1 == actual_1
+    assert expected_2 == actual_2
diff --git a/networkx/algorithms/wiener.py b/networkx/algorithms/wiener.py
index dd998ea33c0..471f8df0cf6 100644
--- a/networkx/algorithms/wiener.py
+++ b/networkx/algorithms/wiener.py
@@ -1,17 +1,25 @@
-"""Functions related to the Wiener index of a graph."""
+"""Functions related to the Wiener Index of a graph.
 
-from itertools import chain
+The Wiener Index is a topological measure of a graph
+related to the distance between nodes and their degree.
+The Schultz Index and Gutman Index are similar measures.
+They are used categorize molecules via the network of
+atoms connected by chemical bonds. The indices are 
+correlated with functional aspects of the molecules.
 
-import networkx as nx
+References
+----------
+.. [1] `Wikipedia: Wiener Index <https://en.wikipedia.org/wiki/Wiener_index>`_
+.. [2] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices,
+       Croatica Chemica Acta, 71 (1998), 21-51.
+       https://hrcak.srce.hr/132323
+"""
 
-from .components import is_connected, is_strongly_connected
-from .shortest_paths import shortest_path_length as spl
+import itertools as it
 
-__all__ = ["wiener_index"]
+import networkx as nx
 
-#: Rename the :func:`chain.from_iterable` function for the sake of
-#: brevity.
-chaini = chain.from_iterable
+__all__ = ["wiener_index", "schultz_index", "gutman_index"]
 
 
 @nx._dispatchable(edge_attrs="weight")
@@ -19,21 +27,23 @@ def wiener_index(G, weight=None):
     """Returns the Wiener index of the given graph.
 
     The *Wiener index* of a graph is the sum of the shortest-path
-    distances between each pair of reachable nodes. For pairs of nodes
-    in undirected graphs, only one orientation of the pair is counted.
+    (weighted) distances between each pair of reachable nodes.
+    For pairs of nodes in undirected graphs, only one orientation
+    of the pair is counted.
 
     Parameters
     ----------
     G : NetworkX graph
 
-    weight : object
-        The edge attribute to use as distance when computing
-        shortest-path distances. This is passed directly to the
-        :func:`networkx.shortest_path_length` function.
+    weight : string or None, optional (default: None)
+        If None, every edge has weight 1.
+        If a string, use this edge attribute as the edge weight.
+        Any edge attribute not present defaults to 1.
+        The edge weights are used to computing shortest-path distances.
 
     Returns
     -------
-    float
+    number
         The Wiener index of the graph `G`.
 
     Raises
@@ -68,12 +78,147 @@ def wiener_index(G, weight=None):
         >>> nx.wiener_index(G)
         inf
 
+    References
+    ----------
+    .. [1] `Wikipedia: Wiener Index <https://en.wikipedia.org/wiki/Wiener_index>`_
     """
-    is_directed = G.is_directed()
-    if (is_directed and not is_strongly_connected(G)) or (
-        not is_directed and not is_connected(G)
-    ):
+    connected = nx.is_strongly_connected(G) if G.is_directed() else nx.is_connected(G)
+    if not connected:
         return float("inf")
-    total = sum(chaini(p.values() for v, p in spl(G, weight=weight)))
+
+    spl = nx.shortest_path_length(G, weight=weight)
+    total = sum(it.chain.from_iterable(nbrs.values() for node, nbrs in spl))
     # Need to account for double counting pairs of nodes in undirected graphs.
-    return total if is_directed else total / 2
+    return total if G.is_directed() else total / 2
+
+
+@nx.utils.not_implemented_for("directed")
+@nx.utils.not_implemented_for("multigraph")
+def schultz_index(G, weight=None):
+    r"""Returns the Schultz Index (of the first kind) of `G`
+
+    The *Schultz Index* [3]_ of a graph is the sum over all node pairs of
+    distances times the sum of degrees. Consider an undirected graph `G`.
+    For each node pair ``(u, v)`` compute ``dist(u, v) * (deg(u) + deg(v)``
+    where ``dist`` is the shortest path length between two nodes and ``deg``
+    is the degree of a node.
+
+    The Schultz Index is the sum of these quantities over all (unordered)
+    pairs of nodes.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        The undirected graph of interest.
+    weight : string or None, optional (default: None)
+        If None, every edge has weight 1.
+        If a string, use this edge attribute as the edge weight.
+        Any edge attribute not present defaults to 1.
+        The edge weights are used to computing shortest-path distances.
+
+    Returns
+    -------
+    number
+        The first kind of Schultz Index of the graph `G`.
+
+    Examples
+    --------
+    The Schultz Index of the (unweighted) complete graph on *n* nodes
+    equals the number of pairs of the *n* nodes times ``2 * (n - 1)``,
+    since each pair of nodes is at distance one and the sum of degree
+    of two nodes is ``2 * (n - 1)``.
+
+    >>> n = 10
+    >>> G = nx.complete_graph(n)
+    >>> nx.schultz_index(G) == (n * (n - 1) / 2) * (2 * (n - 1))
+    True
+
+    Graph that is disconnected
+
+    >>> nx.schultz_index(nx.empty_graph(2))
+    inf
+
+    References
+    ----------
+    .. [1] I. Gutman, Selected properties of the Schultz molecular topological index,
+           J. Chem. Inf. Comput. Sci. 34 (1994), 1087–1089.
+           https://doi.org/10.1021/ci00021a009
+    .. [2] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices,
+           Croatica Chemica Acta, 71 (1998), 21-51.
+           https://hrcak.srce.hr/132323
+    .. [3] H. P. Schultz, Topological organic chemistry. 1.
+           Graph theory and topological indices of alkanes,i
+           J. Chem. Inf. Comput. Sci. 29 (1989), 239–257.
+
+    """
+    if not nx.is_connected(G):
+        return float("inf")
+
+    spl = nx.shortest_path_length(G, weight=weight)
+    d = dict(G.degree, weight=weight)
+    return sum(dist * (d[u] + d[v]) for u, info in spl for v, dist in info.items()) / 2
+
+
+@nx.utils.not_implemented_for("directed")
+@nx.utils.not_implemented_for("multigraph")
+def gutman_index(G, weight=None):
+    r"""Returns the Gutman Index for the graph `G`.
+
+    The *Gutman Index* measures the topology of networks, especially for molecule
+    networks of atoms connected by bonds [1]_. It is also called the Schultz Index
+    of the second kind [2]_.
+
+    Consider an undirected graph `G` with node set ``V``.
+    The Gutman Index of a graph is the sum over all (unordered) pairs of nodes
+    of nodes ``(u, v)``, with distance ``dist(u, v)`` and degrees ``deg(u)``
+    and ``deg(v)``, of ``dist(u, v) * deg(u) * deg(v)``
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    weight : string or None, optional (default: None)
+        If None, every edge has weight 1.
+        If a string, use this edge attribute as the edge weight.
+        Any edge attribute not present defaults to 1.
+        The edge weights are used to computing shortest-path distances.
+
+    Returns
+    -------
+    number
+        The Gutman Index of the graph `G`.
+
+    Examples
+    --------
+    The Gutman Index of the (unweighted) complete graph on *n* nodes
+    equals the number of pairs of the *n* nodes times ``(n - 1) * (n - 1)``,
+    since each pair of nodes is at distance one and the product of degree of two
+    vertices is ``(n - 1) * (n - 1)``.
+
+    >>> n = 10
+    >>> G = nx.complete_graph(n)
+    >>> nx.gutman_index(G) == (n * (n - 1) / 2) * ((n - 1) * (n - 1))
+    True
+
+    Graphs that are disconnected
+
+    >>> G = nx.empty_graph(2)
+    >>> nx.gutman_index(G)
+    inf
+
+    References
+    ----------
+    .. [1] M.V. Diudeaa and I. Gutman, Wiener-Type Topological Indices,
+           Croatica Chemica Acta, 71 (1998), 21-51.
+           https://hrcak.srce.hr/132323
+    .. [2] I. Gutman, Selected properties of the Schultz molecular topological index,
+           J. Chem. Inf. Comput. Sci. 34 (1994), 1087–1089.
+           https://doi.org/10.1021/ci00021a009
+
+    """
+    if not nx.is_connected(G):
+        return float("inf")
+
+    spl = nx.shortest_path_length(G, weight=weight)
+    d = dict(G.degree, weight=weight)
+    return sum(dist * d[u] * d[v] for u, vinfo in spl for v, dist in vinfo.items()) / 2

From b2f98a4cc9d32fbf8f598b5335519e33e0bc3db2 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Sun, 14 Jan 2024 10:38:54 -0800
Subject: [PATCH 041/129] Replace tempfile with tmp_path fixture in test suite.
 (#7221)

* Replace tempfile with tmp_path fixture in test suite.

* A few more instances.
---
 .../bipartite/tests/test_edgelist.py          |  46 +++----
 networkx/drawing/tests/test_agraph.py         |  27 +---
 networkx/drawing/tests/test_pydot.py          |  17 +--
 networkx/readwrite/tests/test_adjlist.py      |  86 ++++--------
 networkx/readwrite/tests/test_edgelist.py     |  56 +++-----
 networkx/readwrite/tests/test_gml.py          | 125 ++++++++----------
 networkx/readwrite/tests/test_graph6.py       |   5 +-
 networkx/readwrite/tests/test_graphml.py      |  56 +++-----
 networkx/readwrite/tests/test_pajek.py        |  19 +--
 networkx/readwrite/tests/test_sparse6.py      |  17 +--
 10 files changed, 164 insertions(+), 290 deletions(-)

diff --git a/networkx/algorithms/bipartite/tests/test_edgelist.py b/networkx/algorithms/bipartite/tests/test_edgelist.py
index b388465ef4b..74035b35e9c 100644
--- a/networkx/algorithms/bipartite/tests/test_edgelist.py
+++ b/networkx/algorithms/bipartite/tests/test_edgelist.py
@@ -2,8 +2,6 @@
     Unit tests for bipartite edgelists.
 """
 import io
-import os
-import tempfile
 
 import pytest
 
@@ -101,51 +99,47 @@ def test_write_edgelist_4(self):
         fh.seek(0)
         assert fh.read() == b"1 2 2.0\n3 2 3.0\n"
 
-    def test_unicode(self):
+    def test_unicode(self, tmp_path):
         G = nx.Graph()
         name1 = chr(2344) + chr(123) + chr(6543)
         name2 = chr(5543) + chr(1543) + chr(324)
         G.add_edge(name1, "Radiohead", **{name2: 3})
         G.add_node(name1, bipartite=0)
         G.add_node("Radiohead", bipartite=1)
-        fd, fname = tempfile.mkstemp()
+
+        fname = tmp_path / "edgelist.txt"
         bipartite.write_edgelist(G, fname)
         H = bipartite.read_edgelist(fname)
         assert graphs_equal(G, H)
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_latin1_issue(self):
+    def test_latin1_issue(self, tmp_path):
         G = nx.Graph()
         name1 = chr(2344) + chr(123) + chr(6543)
         name2 = chr(5543) + chr(1543) + chr(324)
         G.add_edge(name1, "Radiohead", **{name2: 3})
         G.add_node(name1, bipartite=0)
         G.add_node("Radiohead", bipartite=1)
-        fd, fname = tempfile.mkstemp()
-        pytest.raises(
-            UnicodeEncodeError, bipartite.write_edgelist, G, fname, encoding="latin-1"
-        )
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_latin1(self):
+        fname = tmp_path / "edgelist.txt"
+        with pytest.raises(UnicodeEncodeError):
+            bipartite.write_edgelist(G, fname, encoding="latin-1")
+
+    def test_latin1(self, tmp_path):
         G = nx.Graph()
         name1 = "Bj" + chr(246) + "rk"
         name2 = chr(220) + "ber"
         G.add_edge(name1, "Radiohead", **{name2: 3})
         G.add_node(name1, bipartite=0)
         G.add_node("Radiohead", bipartite=1)
-        fd, fname = tempfile.mkstemp()
+
+        fname = tmp_path / "edgelist.txt"
         bipartite.write_edgelist(G, fname, encoding="latin-1")
         H = bipartite.read_edgelist(fname, encoding="latin-1")
         assert graphs_equal(G, H)
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_graph(self):
+    def test_edgelist_graph(self, tmp_path):
         G = self.G
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "edgelist.txt"
         bipartite.write_edgelist(G, fname)
         H = bipartite.read_edgelist(fname)
         H2 = bipartite.read_edgelist(fname)
@@ -153,32 +147,26 @@ def test_edgelist_graph(self):
         G.remove_node("g")  # isolated nodes are not written in edgelist
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_integers(self):
+    def test_edgelist_integers(self, tmp_path):
         G = nx.convert_node_labels_to_integers(self.G)
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "edgelist.txt"
         bipartite.write_edgelist(G, fname)
         H = bipartite.read_edgelist(fname, nodetype=int)
         # isolated nodes are not written in edgelist
         G.remove_nodes_from(list(nx.isolates(G)))
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_multigraph(self):
+    def test_edgelist_multigraph(self, tmp_path):
         G = self.MG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "edgelist.txt"
         bipartite.write_edgelist(G, fname)
         H = bipartite.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
         H2 = bipartite.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
     def test_empty_digraph(self):
         with pytest.raises(nx.NetworkXNotImplemented):
diff --git a/networkx/drawing/tests/test_agraph.py b/networkx/drawing/tests/test_agraph.py
index fd99daaf757..75d5957bf8f 100644
--- a/networkx/drawing/tests/test_agraph.py
+++ b/networkx/drawing/tests/test_agraph.py
@@ -1,6 +1,4 @@
 """Unit tests for PyGraphviz interface."""
-import os
-import tempfile
 import warnings
 
 import pytest
@@ -25,27 +23,26 @@ def assert_equal(self, G1, G2):
         assert edges_equal(G1.edges(), G2.edges())
         assert G1.graph["metal"] == G2.graph["metal"]
 
-    def agraph_checks(self, G):
+    @pytest.mark.parametrize(
+        "G", (nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph())
+    )
+    def test_agraph_roundtripping(self, G, tmp_path):
         G = self.build_graph(G)
         A = nx.nx_agraph.to_agraph(G)
         H = nx.nx_agraph.from_agraph(A)
         self.assert_equal(G, H)
 
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.dot"
         nx.drawing.nx_agraph.write_dot(H, fname)
         Hin = nx.nx_agraph.read_dot(fname)
         self.assert_equal(H, Hin)
-        os.close(fd)
-        os.unlink(fname)
 
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "fh_test.dot"
         with open(fname, "w") as fh:
             nx.drawing.nx_agraph.write_dot(H, fh)
 
         with open(fname) as fh:
             Hin = nx.nx_agraph.read_dot(fh)
-        os.close(fd)
-        os.unlink(fname)
         self.assert_equal(H, Hin)
 
     def test_from_agraph_name(self):
@@ -75,18 +72,6 @@ def test_from_agraph_named_edges(self):
         assert isinstance(H, nx.Graph)
         assert ("0", "1", {"key": "foo"}) in H.edges(data=True)
 
-    def test_undirected(self):
-        self.agraph_checks(nx.Graph())
-
-    def test_directed(self):
-        self.agraph_checks(nx.DiGraph())
-
-    def test_multi_undirected(self):
-        self.agraph_checks(nx.MultiGraph())
-
-    def test_multi_directed(self):
-        self.agraph_checks(nx.MultiDiGraph())
-
     def test_to_agraph_with_nodedata(self):
         G = nx.Graph()
         G.add_node(1, color="red")
diff --git a/networkx/drawing/tests/test_pydot.py b/networkx/drawing/tests/test_pydot.py
index 7085bbecea3..671afac07c5 100644
--- a/networkx/drawing/tests/test_pydot.py
+++ b/networkx/drawing/tests/test_pydot.py
@@ -1,6 +1,4 @@
 """Unit tests for pydot drawing functions."""
-import os
-import tempfile
 from io import StringIO
 
 import pytest
@@ -12,7 +10,9 @@
 
 
 class TestPydot:
-    def pydot_checks(self, G, prog):
+    @pytest.mark.parametrize("G", (nx.Graph(), nx.DiGraph()))
+    @pytest.mark.parametrize("prog", ("neato", "dot"))
+    def test_pydot(self, G, prog, tmp_path):
         """
         Validate :mod:`pydot`-based usage of the passed NetworkX graph with the
         passed basename of an external GraphViz command (e.g., `dot`, `neato`).
@@ -39,7 +39,7 @@ def pydot_checks(self, G, prog):
         # Validate the original and resulting graphs to be the same.
         assert graphs_equal(G, G2)
 
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "out.dot"
 
         # Serialize this "pydot.Dot" instance to a temporary file in dot format
         P.write_raw(fname)
@@ -78,15 +78,6 @@ def pydot_checks(self, G, prog):
         # Validate the original and resulting graphs to be the same.
         assert graphs_equal(G, Hin)
 
-        os.close(fd)
-        os.unlink(fname)
-
-    def test_undirected(self):
-        self.pydot_checks(nx.Graph(), prog="neato")
-
-    def test_directed(self):
-        self.pydot_checks(nx.DiGraph(), prog="dot")
-
     def test_read_write(self):
         G = nx.MultiGraph()
         G.graph["name"] = "G"
diff --git a/networkx/readwrite/tests/test_adjlist.py b/networkx/readwrite/tests/test_adjlist.py
index aecfb87e940..c8d0f54654d 100644
--- a/networkx/readwrite/tests/test_adjlist.py
+++ b/networkx/readwrite/tests/test_adjlist.py
@@ -2,8 +2,6 @@
     Unit tests for adjlist.
 """
 import io
-import os
-import tempfile
 
 import pytest
 
@@ -36,41 +34,35 @@ def test_read_multiline_adjlist_1(self):
         adj = {"1": {"3": {}, "2": {}}, "3": {"1": {}}, "2": {"1": {}}}
         assert graphs_equal(G, nx.Graph(adj))
 
-    def test_unicode(self):
+    def test_unicode(self, tmp_path):
         G = nx.Graph()
         name1 = chr(2344) + chr(123) + chr(6543)
         name2 = chr(5543) + chr(1543) + chr(324)
         G.add_edge(name1, "Radiohead", **{name2: 3})
-        fd, fname = tempfile.mkstemp()
+
+        fname = tmp_path / "adjlist.txt"
         nx.write_multiline_adjlist(G, fname)
         H = nx.read_multiline_adjlist(fname)
         assert graphs_equal(G, H)
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_latin1_err(self):
+    def test_latin1_err(self, tmp_path):
         G = nx.Graph()
         name1 = chr(2344) + chr(123) + chr(6543)
         name2 = chr(5543) + chr(1543) + chr(324)
         G.add_edge(name1, "Radiohead", **{name2: 3})
-        fd, fname = tempfile.mkstemp()
-        pytest.raises(
-            UnicodeEncodeError, nx.write_multiline_adjlist, G, fname, encoding="latin-1"
-        )
-        os.close(fd)
-        os.unlink(fname)
+        fname = tmp_path / "adjlist.txt"
+        with pytest.raises(UnicodeEncodeError):
+            nx.write_multiline_adjlist(G, fname, encoding="latin-1")
 
-    def test_latin1(self):
+    def test_latin1(self, tmp_path):
         G = nx.Graph()
         name1 = "Bj" + chr(246) + "rk"
         name2 = chr(220) + "ber"
         G.add_edge(name1, "Radiohead", **{name2: 3})
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_multiline_adjlist(G, fname, encoding="latin-1")
         H = nx.read_multiline_adjlist(fname, encoding="latin-1")
         assert graphs_equal(G, H)
-        os.close(fd)
-        os.unlink(fname)
 
     def test_parse_adjlist(self):
         lines = ["1 2 5", "2 3 4", "3 5", "4", "5"]
@@ -81,32 +73,28 @@ def test_parse_adjlist(self):
         with pytest.raises(TypeError):
             nx.parse_adjlist(lines, nodetype=int)
 
-    def test_adjlist_graph(self):
+    def test_adjlist_graph(self, tmp_path):
         G = self.G
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_adjlist(G, fname)
         H = nx.read_adjlist(fname)
         H2 = nx.read_adjlist(fname)
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_adjlist_digraph(self):
+    def test_adjlist_digraph(self, tmp_path):
         G = self.DG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_adjlist(G, fname)
         H = nx.read_adjlist(fname, create_using=nx.DiGraph())
         H2 = nx.read_adjlist(fname, create_using=nx.DiGraph())
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_adjlist_integers(self):
-        (fd, fname) = tempfile.mkstemp()
+    def test_adjlist_integers(self, tmp_path):
+        fname = tmp_path / "adjlist.txt"
         G = nx.convert_node_labels_to_integers(self.G)
         nx.write_adjlist(G, fname)
         H = nx.read_adjlist(fname, nodetype=int)
@@ -114,32 +102,26 @@ def test_adjlist_integers(self):
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_adjlist_multigraph(self):
+    def test_adjlist_multigraph(self, tmp_path):
         G = self.XG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_adjlist(G, fname)
         H = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
         H2 = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_adjlist_multidigraph(self):
+    def test_adjlist_multidigraph(self, tmp_path):
         G = self.XDG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_adjlist(G, fname)
         H = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiDiGraph())
         H2 = nx.read_adjlist(fname, nodetype=int, create_using=nx.MultiDiGraph())
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
     def test_adjlist_delimiter(self):
         fh = io.BytesIO()
@@ -192,32 +174,28 @@ def test_parse_multiline_adjlist(self):
         with pytest.raises(TypeError):
             nx.parse_multiline_adjlist(iter(lines))
 
-    def test_multiline_adjlist_graph(self):
+    def test_multiline_adjlist_graph(self, tmp_path):
         G = self.G
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_multiline_adjlist(G, fname)
         H = nx.read_multiline_adjlist(fname)
         H2 = nx.read_multiline_adjlist(fname)
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_multiline_adjlist_digraph(self):
+    def test_multiline_adjlist_digraph(self, tmp_path):
         G = self.DG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_multiline_adjlist(G, fname)
         H = nx.read_multiline_adjlist(fname, create_using=nx.DiGraph())
         H2 = nx.read_multiline_adjlist(fname, create_using=nx.DiGraph())
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_multiline_adjlist_integers(self):
-        (fd, fname) = tempfile.mkstemp()
+    def test_multiline_adjlist_integers(self, tmp_path):
+        fname = tmp_path / "adjlist.txt"
         G = nx.convert_node_labels_to_integers(self.G)
         nx.write_multiline_adjlist(G, fname)
         H = nx.read_multiline_adjlist(fname, nodetype=int)
@@ -225,12 +203,10 @@ def test_multiline_adjlist_integers(self):
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_multiline_adjlist_multigraph(self):
+    def test_multiline_adjlist_multigraph(self, tmp_path):
         G = self.XG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_multiline_adjlist(G, fname)
         H = nx.read_multiline_adjlist(fname, nodetype=int, create_using=nx.MultiGraph())
         H2 = nx.read_multiline_adjlist(
@@ -239,12 +215,10 @@ def test_multiline_adjlist_multigraph(self):
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_multiline_adjlist_multidigraph(self):
+    def test_multiline_adjlist_multidigraph(self, tmp_path):
         G = self.XDG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "adjlist.txt"
         nx.write_multiline_adjlist(G, fname)
         H = nx.read_multiline_adjlist(
             fname, nodetype=int, create_using=nx.MultiDiGraph()
@@ -255,8 +229,6 @@ def test_multiline_adjlist_multidigraph(self):
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
     def test_multiline_adjlist_delimiter(self):
         fh = io.BytesIO()
diff --git a/networkx/readwrite/tests/test_edgelist.py b/networkx/readwrite/tests/test_edgelist.py
index 18b726f4380..29a536d53e9 100644
--- a/networkx/readwrite/tests/test_edgelist.py
+++ b/networkx/readwrite/tests/test_edgelist.py
@@ -2,8 +2,6 @@
     Unit tests for edgelists.
 """
 import io
-import os
-import tempfile
 import textwrap
 
 import pytest
@@ -215,45 +213,39 @@ def test_write_edgelist_4(self):
         fh.seek(0)
         assert fh.read() == b"1 2 2.0\n2 3 3.0\n"
 
-    def test_unicode(self):
+    def test_unicode(self, tmp_path):
         G = nx.Graph()
         name1 = chr(2344) + chr(123) + chr(6543)
         name2 = chr(5543) + chr(1543) + chr(324)
         G.add_edge(name1, "Radiohead", **{name2: 3})
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "el.txt"
         nx.write_edgelist(G, fname)
         H = nx.read_edgelist(fname)
         assert graphs_equal(G, H)
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_latin1_issue(self):
+    def test_latin1_issue(self, tmp_path):
         G = nx.Graph()
         name1 = chr(2344) + chr(123) + chr(6543)
         name2 = chr(5543) + chr(1543) + chr(324)
         G.add_edge(name1, "Radiohead", **{name2: 3})
-        fd, fname = tempfile.mkstemp()
-        pytest.raises(
-            UnicodeEncodeError, nx.write_edgelist, G, fname, encoding="latin-1"
-        )
-        os.close(fd)
-        os.unlink(fname)
+        fname = tmp_path / "el.txt"
+        with pytest.raises(UnicodeEncodeError):
+            nx.write_edgelist(G, fname, encoding="latin-1")
 
-    def test_latin1(self):
+    def test_latin1(self, tmp_path):
         G = nx.Graph()
         name1 = "Bj" + chr(246) + "rk"
         name2 = chr(220) + "ber"
         G.add_edge(name1, "Radiohead", **{name2: 3})
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "el.txt"
+
         nx.write_edgelist(G, fname, encoding="latin-1")
         H = nx.read_edgelist(fname, encoding="latin-1")
         assert graphs_equal(G, H)
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_graph(self):
+    def test_edgelist_graph(self, tmp_path):
         G = self.G
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "el.txt"
         nx.write_edgelist(G, fname)
         H = nx.read_edgelist(fname)
         H2 = nx.read_edgelist(fname)
@@ -261,12 +253,10 @@ def test_edgelist_graph(self):
         G.remove_node("g")  # isolated nodes are not written in edgelist
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_digraph(self):
+    def test_edgelist_digraph(self, tmp_path):
         G = self.DG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "el.txt"
         nx.write_edgelist(G, fname)
         H = nx.read_edgelist(fname, create_using=nx.DiGraph())
         H2 = nx.read_edgelist(fname, create_using=nx.DiGraph())
@@ -274,41 +264,33 @@ def test_edgelist_digraph(self):
         G.remove_node("g")  # isolated nodes are not written in edgelist
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_integers(self):
+    def test_edgelist_integers(self, tmp_path):
         G = nx.convert_node_labels_to_integers(self.G)
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "el.txt"
         nx.write_edgelist(G, fname)
         H = nx.read_edgelist(fname, nodetype=int)
         # isolated nodes are not written in edgelist
         G.remove_nodes_from(list(nx.isolates(G)))
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_multigraph(self):
+    def test_edgelist_multigraph(self, tmp_path):
         G = self.XG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "el.txt"
         nx.write_edgelist(G, fname)
         H = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
         H2 = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiGraph())
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_edgelist_multidigraph(self):
+    def test_edgelist_multidigraph(self, tmp_path):
         G = self.XDG
-        (fd, fname) = tempfile.mkstemp()
+        fname = tmp_path / "el.txt"
         nx.write_edgelist(G, fname)
         H = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiDiGraph())
         H2 = nx.read_edgelist(fname, nodetype=int, create_using=nx.MultiDiGraph())
         assert H is not H2  # they should be different graphs
         assert nodes_equal(list(H), list(G))
         assert edges_equal(list(H.edges()), list(G.edges()))
-        os.close(fd)
-        os.unlink(fname)
diff --git a/networkx/readwrite/tests/test_gml.py b/networkx/readwrite/tests/test_gml.py
index 50eff5c3617..f575ad269cf 100644
--- a/networkx/readwrite/tests/test_gml.py
+++ b/networkx/readwrite/tests/test_gml.py
@@ -1,8 +1,6 @@
 import codecs
 import io
 import math
-import os
-import tempfile
 from ast import literal_eval
 from contextlib import contextmanager
 from textwrap import dedent
@@ -165,17 +163,14 @@ def test_parse_gml(self):
             ("Node 3", "Node 1", {"label": "Edge from node 3 to node 1"}),
         ]
 
-    def test_read_gml(self):
-        (fd, fname) = tempfile.mkstemp()
-        fh = open(fname, "w")
-        fh.write(self.simple_data)
-        fh.close()
+    def test_read_gml(self, tmp_path):
+        fname = tmp_path / "test.gml"
+        with open(fname, "w") as fh:
+            fh.write(self.simple_data)
         Gin = nx.read_gml(fname, label="label")
         G = nx.parse_gml(self.simple_data, label="label")
         assert sorted(G.nodes(data=True)) == sorted(Gin.nodes(data=True))
         assert sorted(G.edges(data=True)) == sorted(Gin.edges(data=True))
-        os.close(fd)
-        os.unlink(fname)
 
     def test_labels_are_strings(self):
         # GML requires labels to be strings (i.e., in quotes)
@@ -235,18 +230,18 @@ def test_tuplelabels(self, stringizer):
 ]"""
         assert data == answer
 
-    def test_quotes(self):
+    def test_quotes(self, tmp_path):
         # https://github.com/networkx/networkx/issues/1061
         # Encoding quotes as HTML entities.
         G = nx.path_graph(1)
         G.name = "path_graph(1)"
         attr = 'This is "quoted" and this is a copyright: ' + chr(169)
         G.nodes[0]["demo"] = attr
-        fobj = tempfile.NamedTemporaryFile()
-        nx.write_gml(G, fobj)
-        fobj.seek(0)
-        # Should be bytes in 2.x and 3.x
-        data = fobj.read().strip().decode("ascii")
+        with open(tmp_path / "test.gml", "w+b") as fobj:
+            nx.write_gml(G, fobj)
+            fobj.seek(0)
+            # Should be bytes in 2.x and 3.x
+            data = fobj.read().strip().decode("ascii")
         answer = """graph [
   name "path_graph(1)"
   node [
@@ -257,15 +252,15 @@ def test_quotes(self):
 ]"""
         assert data == answer
 
-    def test_unicode_node(self):
+    def test_unicode_node(self, tmp_path):
         node = "node" + chr(169)
         G = nx.Graph()
         G.add_node(node)
-        fobj = tempfile.NamedTemporaryFile()
-        nx.write_gml(G, fobj)
-        fobj.seek(0)
-        # Should be bytes in 2.x and 3.x
-        data = fobj.read().strip().decode("ascii")
+        with open(tmp_path / "test.gml", "w+b") as fobj:
+            nx.write_gml(G, fobj)
+            fobj.seek(0)
+            # Should be bytes in 2.x and 3.x
+            data = fobj.read().strip().decode("ascii")
         answer = """graph [
   node [
     id 0
@@ -274,15 +269,15 @@ def test_unicode_node(self):
 ]"""
         assert data == answer
 
-    def test_float_label(self):
+    def test_float_label(self, tmp_path):
         node = 1.0
         G = nx.Graph()
         G.add_node(node)
-        fobj = tempfile.NamedTemporaryFile()
-        nx.write_gml(G, fobj)
-        fobj.seek(0)
-        # Should be bytes in 2.x and 3.x
-        data = fobj.read().strip().decode("ascii")
+        with open(tmp_path / "test.gml", "w+b") as fobj:
+            nx.write_gml(G, fobj)
+            fobj.seek(0)
+            # Should be bytes in 2.x and 3.x
+            data = fobj.read().strip().decode("ascii")
         answer = """graph [
   node [
     id 0
@@ -291,7 +286,7 @@ def test_float_label(self):
 ]"""
         assert data == answer
 
-    def test_special_float_label(self):
+    def test_special_float_label(self, tmp_path):
         special_floats = [float("nan"), float("+inf"), float("-inf")]
         try:
             import numpy as np
@@ -307,12 +302,12 @@ def test_special_float_label(self):
         attrs = {edges[i]: value for i, value in enumerate(special_floats)}
         nx.set_edge_attributes(G, attrs, "edgefloat")
 
-        fobj = tempfile.NamedTemporaryFile()
-        nx.write_gml(G, fobj)
-        fobj.seek(0)
-        # Should be bytes in 2.x and 3.x
-        data = fobj.read().strip().decode("ascii")
-        answer = """graph [
+        with open(tmp_path / "test.gml", "w+b") as fobj:
+            nx.write_gml(G, fobj)
+            fobj.seek(0)
+            # Should be bytes in 2.x and 3.x
+            data = fobj.read().strip().decode("ascii")
+            answer = """graph [
   node [
     id 0
     label "0"
@@ -374,24 +369,24 @@ def test_special_float_label(self):
     edgefloat -INF
   ]
 ]"""
-        assert data == answer
-
-        fobj.seek(0)
-        graph = nx.read_gml(fobj)
-        for indx, value in enumerate(special_floats):
-            node_value = graph.nodes[str(indx)]["nodefloat"]
-            if math.isnan(value):
-                assert math.isnan(node_value)
-            else:
-                assert node_value == value
+            assert data == answer
+
+            fobj.seek(0)
+            graph = nx.read_gml(fobj)
+            for indx, value in enumerate(special_floats):
+                node_value = graph.nodes[str(indx)]["nodefloat"]
+                if math.isnan(value):
+                    assert math.isnan(node_value)
+                else:
+                    assert node_value == value
 
-            edge = edges[indx]
-            string_edge = (str(edge[0]), str(edge[1]))
-            edge_value = graph.edges[string_edge]["edgefloat"]
-            if math.isnan(value):
-                assert math.isnan(edge_value)
-            else:
-                assert edge_value == value
+                edge = edges[indx]
+                string_edge = (str(edge[0]), str(edge[1]))
+                edge_value = graph.edges[string_edge]["edgefloat"]
+                if math.isnan(value):
+                    assert math.isnan(edge_value)
+                else:
+                    assert edge_value == value
 
     def test_name(self):
         G = nx.parse_gml('graph [ name "x" node [ id 0 label "x" ] ]')
@@ -480,13 +475,13 @@ def test_escape_unescape(self):
         )
         assert answer == gml
 
-    def test_exceptions(self):
+    def test_exceptions(self, tmp_path):
         pytest.raises(ValueError, literal_destringizer, "(")
         pytest.raises(ValueError, literal_destringizer, "frozenset([1, 2, 3])")
         pytest.raises(ValueError, literal_destringizer, literal_destringizer)
         pytest.raises(ValueError, literal_stringizer, frozenset([1, 2, 3]))
         pytest.raises(ValueError, literal_stringizer, literal_stringizer)
-        with tempfile.TemporaryFile() as f:
+        with open(tmp_path / "test.gml", "w+b") as f:
             f.write(codecs.BOM_UTF8 + b"graph[]")
             f.seek(0)
             pytest.raises(nx.NetworkXError, nx.read_gml, f)
@@ -584,7 +579,7 @@ def test_label_kwarg(self):
         labels = [G.nodes[n]["label"] for n in sorted(G.nodes)]
         assert labels == ["Node 1", "Node 2", "Node 3"]
 
-    def test_outofrange_integers(self):
+    def test_outofrange_integers(self, tmp_path):
         # GML restricts integers to 32 signed bits.
         # Check that we honor this restriction on export
         G = nx.Graph()
@@ -601,19 +596,15 @@ def test_outofrange_integers(self):
         }
         G.add_node("Node", **numbers)
 
-        fd, fname = tempfile.mkstemp()
-        try:
-            nx.write_gml(G, fname)
-            # Check that the export wrote the nonfitting numbers as strings
-            G2 = nx.read_gml(fname)
-            for attr, value in G2.nodes["Node"].items():
-                if attr == "toosmall" or attr == "toobig":
-                    assert type(value) == str
-                else:
-                    assert type(value) == int
-        finally:
-            os.close(fd)
-            os.unlink(fname)
+        fname = tmp_path / "test.gml"
+        nx.write_gml(G, fname)
+        # Check that the export wrote the nonfitting numbers as strings
+        G2 = nx.read_gml(fname)
+        for attr, value in G2.nodes["Node"].items():
+            if attr == "toosmall" or attr == "toobig":
+                assert type(value) == str
+            else:
+                assert type(value) == int
 
     def test_multiline(self):
         # example from issue #6836
diff --git a/networkx/readwrite/tests/test_graph6.py b/networkx/readwrite/tests/test_graph6.py
index 062a96f0b12..a80326946c6 100644
--- a/networkx/readwrite/tests/test_graph6.py
+++ b/networkx/readwrite/tests/test_graph6.py
@@ -1,4 +1,3 @@
-import tempfile
 from io import BytesIO
 
 import pytest
@@ -104,8 +103,8 @@ def test_roundtrip(self):
             assert nodes_equal(G.nodes(), H.nodes())
             assert edges_equal(G.edges(), H.edges())
 
-    def test_write_path(self):
-        with tempfile.NamedTemporaryFile() as f:
+    def test_write_path(self, tmp_path):
+        with open(tmp_path / "test.g6", "w+b") as f:
             g6.write_graph6_file(nx.null_graph(), f)
             f.seek(0)
             assert f.read() == b">>graph6<<?\n"
diff --git a/networkx/readwrite/tests/test_graphml.py b/networkx/readwrite/tests/test_graphml.py
index a58f44d6723..2d87026ae8a 100644
--- a/networkx/readwrite/tests/test_graphml.py
+++ b/networkx/readwrite/tests/test_graphml.py
@@ -1,6 +1,4 @@
 import io
-import os
-import tempfile
 
 import pytest
 
@@ -1210,7 +1208,7 @@ def test_write_read_attribute_numeric_type_graphml(self):
         assert ("attr.type", "double") in keys[0]
         assert ("attr.type", "double") in keys[1]
 
-    def test_more_multigraph_keys(self):
+    def test_more_multigraph_keys(self, tmp_path):
         """Writing keys as edge id attributes means keys become strings.
         The original keys are stored as data, so read them back in
         if `str(key) == edge_id`
@@ -1218,14 +1216,12 @@ def test_more_multigraph_keys(self):
         """
         G = nx.MultiGraph()
         G.add_edges_from([("a", "b", 2), ("a", "b", 3)])
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         self.writer(G, fname)
         H = nx.read_graphml(fname)
         assert H.is_multigraph()
         assert edges_equal(G.edges(keys=True), H.edges(keys=True))
         assert G._adj == H._adj
-        os.close(fd)
-        os.unlink(fname)
 
     def test_default_attribute(self):
         G = nx.Graph(name="Fred")
@@ -1288,38 +1284,34 @@ def test_mixed_int_type_number_attributes(self):
         assert H.edges["n0", "n1", 0]["special"] == 2
         assert H.edges["n0", "n1", 1]["special"] == 3
 
-    def test_multigraph_to_graph(self):
+    def test_multigraph_to_graph(self, tmp_path):
         # test converting multigraph to graph if no parallel edges found
         G = nx.MultiGraph()
         G.add_edges_from([("a", "b", 2), ("b", "c", 3)])  # no multiedges
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         self.writer(G, fname)
         H = nx.read_graphml(fname)
         assert not H.is_multigraph()
         H = nx.read_graphml(fname, force_multigraph=True)
         assert H.is_multigraph()
-        os.close(fd)
-        os.unlink(fname)
 
         # add a multiedge
         G.add_edge("a", "b", "e-id")
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         self.writer(G, fname)
         H = nx.read_graphml(fname)
         assert H.is_multigraph()
         H = nx.read_graphml(fname, force_multigraph=True)
         assert H.is_multigraph()
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_write_generate_edge_id_from_attribute(self):
+    def test_write_generate_edge_id_from_attribute(self, tmp_path):
         from xml.etree.ElementTree import parse
 
         G = nx.Graph()
         G.add_edges_from([("a", "b"), ("b", "c"), ("a", "c")])
         edge_attributes = {e: str(e) for e in G.edges}
         nx.set_edge_attributes(G, edge_attributes, "eid")
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         # set edge_id_from_attribute e.g. "eid" for write_graphml()
         self.writer(G, fname, edge_id_from_attribute="eid")
         # set edge_id_from_attribute e.g. "eid" for generate_graphml()
@@ -1353,17 +1345,14 @@ def test_write_generate_edge_id_from_attribute(self):
         nx.set_edge_attributes(G, edge_attributes, "id")
         assert edges_equal(G.edges(data=True), J.edges(data=True))
 
-        os.close(fd)
-        os.unlink(fname)
-
-    def test_multigraph_write_generate_edge_id_from_attribute(self):
+    def test_multigraph_write_generate_edge_id_from_attribute(self, tmp_path):
         from xml.etree.ElementTree import parse
 
         G = nx.MultiGraph()
         G.add_edges_from([("a", "b"), ("b", "c"), ("a", "c"), ("a", "b")])
         edge_attributes = {e: str(e) for e in G.edges}
         nx.set_edge_attributes(G, edge_attributes, "eid")
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         # set edge_id_from_attribute e.g. "eid" for write_graphml()
         self.writer(G, fname, edge_id_from_attribute="eid")
         # set edge_id_from_attribute e.g. "eid" for generate_graphml()
@@ -1411,14 +1400,11 @@ def test_multigraph_write_generate_edge_id_from_attribute(self):
             edge_attributes.values()
         )
 
-        os.close(fd)
-        os.unlink(fname)
-
-    def test_numpy_float64(self):
+    def test_numpy_float64(self, tmp_path):
         np = pytest.importorskip("numpy")
         wt = np.float64(3.4)
         G = nx.Graph([(1, 2, {"weight": wt})])
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         self.writer(G, fname)
         H = nx.read_graphml(fname, node_type=int)
         assert G.edges == H.edges
@@ -1427,14 +1413,12 @@ def test_numpy_float64(self):
         assert wtG == pytest.approx(wtH, abs=1e-6)
         assert type(wtG) == np.float64
         assert type(wtH) == float
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_numpy_float32(self):
+    def test_numpy_float32(self, tmp_path):
         np = pytest.importorskip("numpy")
         wt = np.float32(3.4)
         G = nx.Graph([(1, 2, {"weight": wt})])
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         self.writer(G, fname)
         H = nx.read_graphml(fname, node_type=int)
         assert G.edges == H.edges
@@ -1443,32 +1427,26 @@ def test_numpy_float32(self):
         assert wtG == pytest.approx(wtH, abs=1e-6)
         assert type(wtG) == np.float32
         assert type(wtH) == float
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_numpy_float64_inference(self):
+    def test_numpy_float64_inference(self, tmp_path):
         np = pytest.importorskip("numpy")
         G = self.attribute_numeric_type_graph
         G.edges[("n1", "n1")]["weight"] = np.float64(1.1)
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         self.writer(G, fname, infer_numeric_types=True)
         H = nx.read_graphml(fname)
         assert G._adj == H._adj
-        os.close(fd)
-        os.unlink(fname)
 
-    def test_unicode_attributes(self):
+    def test_unicode_attributes(self, tmp_path):
         G = nx.Graph()
         name1 = chr(2344) + chr(123) + chr(6543)
         name2 = chr(5543) + chr(1543) + chr(324)
         node_type = str
         G.add_edge(name1, "Radiohead", foo=name2)
-        fd, fname = tempfile.mkstemp()
+        fname = tmp_path / "test.graphml"
         self.writer(G, fname)
         H = nx.read_graphml(fname, node_type=node_type)
         assert G._adj == H._adj
-        os.close(fd)
-        os.unlink(fname)
 
     def test_unicode_escape(self):
         # test for handling json escaped strings in python 2 Issue #1880
diff --git a/networkx/readwrite/tests/test_pajek.py b/networkx/readwrite/tests/test_pajek.py
index e617c3fc75c..6160c8bce03 100644
--- a/networkx/readwrite/tests/test_pajek.py
+++ b/networkx/readwrite/tests/test_pajek.py
@@ -1,9 +1,6 @@
 """
 Pajek tests
 """
-import os
-import tempfile
-
 import networkx as nx
 from networkx.utils import edges_equal, nodes_equal
 
@@ -27,13 +24,6 @@ def setup_class(cls):
         )
 
         cls.G.graph["name"] = "Tralala"
-        (fd, cls.fname) = tempfile.mkstemp()
-        with os.fdopen(fd, "wb") as fh:
-            fh.write(cls.data.encode("UTF-8"))
-
-    @classmethod
-    def teardown_class(cls):
-        os.unlink(cls.fname)
 
     def test_parse_pajek_simple(self):
         # Example without node positions or shape
@@ -68,9 +58,14 @@ def test_parse_pajet_mat(self):
             {("one", "one"), ("two", "one"), ("two", "two"), ("two", "three")},
         )
 
-    def test_read_pajek(self):
+    def test_read_pajek(self, tmp_path):
         G = nx.parse_pajek(self.data)
-        Gin = nx.read_pajek(self.fname)
+        # Read data from file
+        fname = tmp_path / "test.pjk"
+        with open(fname, "wb") as fh:
+            fh.write(self.data.encode("UTF-8"))
+
+        Gin = nx.read_pajek(fname)
         assert sorted(G.nodes()) == sorted(Gin.nodes())
         assert edges_equal(G.edges(), Gin.edges())
         assert self.G.graph == Gin.graph
diff --git a/networkx/readwrite/tests/test_sparse6.py b/networkx/readwrite/tests/test_sparse6.py
index c8b5e4de93e..344ad0e45ff 100644
--- a/networkx/readwrite/tests/test_sparse6.py
+++ b/networkx/readwrite/tests/test_sparse6.py
@@ -1,4 +1,3 @@
-import tempfile
 from io import BytesIO
 
 import pytest
@@ -158,16 +157,10 @@ def test_no_directed_graphs(self):
         with pytest.raises(nx.NetworkXNotImplemented):
             nx.write_sparse6(nx.DiGraph(), BytesIO())
 
-    def test_write_path(self):
-        # On Windows, we can't reopen a file that is open
-        # So, for test we get a valid name from tempfile but close it.
-        with tempfile.NamedTemporaryFile() as f:
-            fullfilename = f.name
+    def test_write_path(self, tmp_path):
+        # Get a valid temporary file name
+        fullfilename = str(tmp_path / "test.s6")
         # file should be closed now, so write_sparse6 can open it
         nx.write_sparse6(nx.null_graph(), fullfilename)
-        fh = open(fullfilename, mode="rb")
-        assert fh.read() == b">>sparse6<<:?\n"
-        fh.close()
-        import os
-
-        os.remove(fullfilename)
+        with open(fullfilename, mode="rb") as fh:
+            assert fh.read() == b">>sparse6<<:?\n"

From 8682e1b47d72530b3200e2055a06d7a287ee0f7f Mon Sep 17 00:00:00 2001
From: Maximilian Seeliger <maximilian.seeliger@gmail.com>
Date: Tue, 16 Jan 2024 04:18:16 +0100
Subject: [PATCH 042/129] Fixed typo in tensor product documentation (Fixes
 #7228) (#7229)

Fixed typo
---
 networkx/algorithms/operators/product.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/networkx/algorithms/operators/product.py b/networkx/algorithms/operators/product.py
index 9a8063c91e2..3128f82b40b 100644
--- a/networkx/algorithms/operators/product.py
+++ b/networkx/algorithms/operators/product.py
@@ -128,7 +128,7 @@ def tensor_product(G, H):
     r"""Returns the tensor product of G and H.
 
     The tensor product $P$ of the graphs $G$ and $H$ has a node set that
-    is the tensor product of the node sets, $V(P)=V(G) \times V(H)$.
+    is the Cartesian product of the node sets, $V(P)=V(G) \times V(H)$.
     $P$ has an edge $((u,v), (x,y))$ if and only if $(u,x)$ is an edge in $G$
     and $(v,y)$ is an edge in $H$.
 

From 4a0a6754a58ed46ffa0d193e2b4951f9884d206e Mon Sep 17 00:00:00 2001
From: Dishie Vinchhi <95416713+Dishie2498@users.noreply.github.com>
Date: Thu, 18 Jan 2024 00:22:15 +0530
Subject: [PATCH 043/129] updated test_directed_edge_swap to fix #5814  (#6426)

* rewrite test to ensure edges are swapped

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/swap.py            |  2 ++
 networkx/algorithms/tests/test_swap.py | 38 ++++++++++++++++++++------
 2 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/networkx/algorithms/swap.py b/networkx/algorithms/swap.py
index 1b6133e4a69..6c4b698f1ad 100644
--- a/networkx/algorithms/swap.py
+++ b/networkx/algorithms/swap.py
@@ -57,6 +57,8 @@ def directed_edge_swap(G, *, nswap=1, max_tries=100, seed=None):
 
     The graph G is modified in place.
 
+    A later swap is allowed to undo a previous swap.
+
     References
     ----------
     .. [1] Erdős, Péter L., et al. “A Simple Havel-Hakimi Type Algorithm to Realize
diff --git a/networkx/algorithms/tests/test_swap.py b/networkx/algorithms/tests/test_swap.py
index 49dd5f8e8c7..378c8ecfa61 100644
--- a/networkx/algorithms/tests/test_swap.py
+++ b/networkx/algorithms/tests/test_swap.py
@@ -2,14 +2,36 @@
 
 import networkx as nx
 
-
-def test_directed_edge_swap():
-    graph = nx.path_graph(200, create_using=nx.DiGraph)
-    in_degrees = sorted((n, d) for n, d in graph.in_degree())
-    out_degrees = sorted((n, d) for n, d in graph.out_degree())
-    G = nx.directed_edge_swap(graph, nswap=40, max_tries=500, seed=1)
-    assert in_degrees == sorted((n, d) for n, d in G.in_degree())
-    assert out_degrees == sorted((n, d) for n, d in G.out_degree())
+cycle = nx.cycle_graph(5, create_using=nx.DiGraph)
+tree = nx.random_tree(10, create_using=nx.DiGraph)
+path = nx.path_graph(5, create_using=nx.DiGraph)
+binomial = nx.binomial_tree(3, create_using=nx.DiGraph)
+HH = nx.directed_havel_hakimi_graph([1, 2, 1, 2, 2, 2], [3, 1, 0, 1, 2, 3])
+balanced_tree = nx.balanced_tree(2, 3, create_using=nx.DiGraph)
+
+
+@pytest.mark.parametrize("G", [path, binomial, HH, cycle, tree, balanced_tree])
+def test_directed_edge_swap(G):
+    in_degree = set(G.in_degree)
+    out_degree = set(G.out_degree)
+    edges = set(G.edges)
+    nx.directed_edge_swap(G, nswap=1, max_tries=100, seed=1)
+    assert in_degree == set(G.in_degree)
+    assert out_degree == set(G.out_degree)
+    assert edges != set(G.edges)
+    assert 3 == sum(e not in edges for e in G.edges)
+
+
+def test_directed_edge_swap_undo_previous_swap():
+    G = nx.DiGraph(nx.path_graph(4).edges)  # only 1 swap possible
+    edges = set(G.edges)
+    nx.directed_edge_swap(G, nswap=2, max_tries=100)
+    assert edges == set(G.edges)
+
+    nx.directed_edge_swap(G, nswap=1, max_tries=100, seed=1)
+    assert {(0, 2), (1, 3), (2, 1)} == set(G.edges)
+    nx.directed_edge_swap(G, nswap=1, max_tries=100, seed=1)
+    assert edges == set(G.edges)
 
 
 def test_edge_cases_directed_edge_swap():

From 40e84a489c9de00711b844392eb8087806d93f52 Mon Sep 17 00:00:00 2001
From: Purvi Chaurasia <97350598+PurviChaurasia@users.noreply.github.com>
Date: Thu, 18 Jan 2024 00:25:34 +0530
Subject: [PATCH 044/129] Add example for cycle detection (#6560)

* Fix negative edge cycle function raising exception for empty graph and added relevant test function

* Unresolved change

* Added example script to visualize GOT network

* Added example script to visualize cycle detection

* Deleted got.py

* Minor tweaks to example.

* Update examples/algorithms/plot_cycle_detection.py

---------

Co-authored-by: Ross Barnowski <rossbar@caltech.edu>
Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 examples/algorithms/plot_cycle_detection.py | 29 +++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 examples/algorithms/plot_cycle_detection.py

diff --git a/examples/algorithms/plot_cycle_detection.py b/examples/algorithms/plot_cycle_detection.py
new file mode 100644
index 00000000000..cd22f750736
--- /dev/null
+++ b/examples/algorithms/plot_cycle_detection.py
@@ -0,0 +1,29 @@
+"""
+===============
+Cycle Detection
+===============
+
+This example demonstrates the use of ``nx.find_cycle`` to find a single,
+arbitrary cycle in a graph.
+
+Other functions like ``nx.simple_cycles`` and ``nx.cycle_basis`` can be used to
+find all cycles or a cycle basis.
+"""
+import networkx as nx
+import matplotlib.pyplot as plt
+
+# Create a simple directed graph with a cycle
+G = nx.DiGraph([(1, 2), (2, 3), (3, 4), (4, 2), (3, 5), (3, 2), (1, 5)])
+
+# Draw the graph
+pos = nx.spring_layout(G, seed=8020)
+nx.draw(G, pos, with_labels=True)
+
+# The `orientation` parameter can be used to determine how directed edges are
+# treated and the reporting of edge direction in the cycle
+cycle = nx.find_cycle(G, orientation="original")
+print(cycle)
+
+# Highlight the cycle in red
+nx.draw_networkx_edges(G, pos, edgelist=cycle, edge_color="r", width=2)
+plt.show()

From 7fc4fa51875d9e326416f998c51f208442d55dad Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Thu, 18 Jan 2024 00:38:08 -0800
Subject: [PATCH 045/129] Bump copyright year for 2024. (#7232)

---
 LICENSE.txt | 2 +-
 README.rst  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/LICENSE.txt b/LICENSE.txt
index 42b6f17a65e..100b4bffb00 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -2,7 +2,7 @@ NetworkX is distributed with the 3-clause BSD license.
 
 ::
 
-   Copyright (C) 2004-2023, NetworkX Developers
+   Copyright (C) 2004-2024, NetworkX Developers
    Aric Hagberg <hagberg@lanl.gov>
    Dan Schult <dschult@colgate.edu>
    Pieter Swart <swart@lanl.gov>
diff --git a/README.rst b/README.rst
index 11bd027f974..9e4be00835b 100644
--- a/README.rst
+++ b/README.rst
@@ -67,7 +67,7 @@ License
 
 Released under the 3-Clause BSD license (see `LICENSE.txt`)::
 
-   Copyright (C) 2004-2023 NetworkX Developers
+   Copyright (C) 2004-2024 NetworkX Developers
    Aric Hagberg <hagberg@lanl.gov>
    Dan Schult <dschult@colgate.edu>
    Pieter Swart <swart@lanl.gov>

From 3eecad33aebd83ddd0c03e69c9cb02f84d8ad451 Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Sat, 20 Jan 2024 02:05:52 +0400
Subject: [PATCH 046/129] Divisive community algorithms (#5830)

* Divisive community algorithms

* Cleanup divisive community algos

* Change number_of_partitions to number of sets, doc_string tweaks,

examples, etc

* Rewrite so CF Btwness is called on each component separately

* importorskip numpy for edge_current_flow_betweenness

* fix isort trouble

* Apply suggestions from code review

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>

* FEAT: adding a PoC of creating an internal cache

---------

Co-authored-by: Benjamin Edwards <BJEdwards@gmail.com>
Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 doc/reference/algorithms/community.rst        |   9 +
 networkx/algorithms/community/__init__.py     |   1 +
 networkx/algorithms/community/divisive.py     | 194 ++++++++++++++++++
 .../community/tests/test_divisive.py          | 109 ++++++++++
 4 files changed, 313 insertions(+)
 create mode 100644 networkx/algorithms/community/divisive.py
 create mode 100644 networkx/algorithms/community/tests/test_divisive.py

diff --git a/doc/reference/algorithms/community.rst b/doc/reference/algorithms/community.rst
index 1d107099790..b031bcb349b 100644
--- a/doc/reference/algorithms/community.rst
+++ b/doc/reference/algorithms/community.rst
@@ -14,6 +14,15 @@ Bipartitions
 
    kernighan_lin_bisection
 
+Divisive Communities
+---------------------
+.. automodule:: networkx.algorithms.community.divisive
+.. autosummary::
+   :toctree: generated/
+
+   edge_betweenness_partition
+   edge_current_flow_betweenness_partition
+
 K-Clique
 --------
 .. automodule:: networkx.algorithms.community.kclique
diff --git a/networkx/algorithms/community/__init__.py b/networkx/algorithms/community/__init__.py
index fa782201ddc..40549aff238 100644
--- a/networkx/algorithms/community/__init__.py
+++ b/networkx/algorithms/community/__init__.py
@@ -14,6 +14,7 @@
 """
 from networkx.algorithms.community.asyn_fluid import *
 from networkx.algorithms.community.centrality import *
+from networkx.algorithms.community.divisive import *
 from networkx.algorithms.community.kclique import *
 from networkx.algorithms.community.kernighan_lin import *
 from networkx.algorithms.community.label_propagation import *
diff --git a/networkx/algorithms/community/divisive.py b/networkx/algorithms/community/divisive.py
new file mode 100644
index 00000000000..7dbf70ca3fd
--- /dev/null
+++ b/networkx/algorithms/community/divisive.py
@@ -0,0 +1,194 @@
+import functools
+
+import networkx as nx
+
+__all__ = [
+    "edge_betweenness_partition",
+    "edge_current_flow_betweenness_partition",
+]
+
+
+def edge_betweenness_partition(G, number_of_sets, *, weight=None):
+    """Partition created by iteratively removing the highest edge betweenness edge.
+
+    This algorithm works by calculating the edge betweenness for all
+    edges and removing the edge with the highest value. It is then
+    determined whether the graph has been broken into at least
+    `number_of_sets` connected components.
+    If not the process is repeated.
+
+    Parameters
+    ----------
+    G : NetworkX Graph, DiGraph or MultiGraph
+      Graph to be partitioned
+
+    number_of_sets : int
+      Number of sets in the desired partition of the graph
+
+    weight : key, optional, default=None
+      The key to use if using weights for edge betweenness calculation
+
+    Returns
+    -------
+    C : list of sets
+      Partition of the nodes of G
+
+    Raises
+    ------
+    NetworkXError
+      If number_of_sets is <= 0 or if number_of_sets > len(G)
+
+    Examples
+    --------
+    >>> G = nx.karate_club_graph()
+    >>> part = nx.community.edge_betweenness_partition(G, 2)
+    >>> {0, 1, 3, 4, 5, 6, 7, 10, 11, 12, 13, 16, 17, 19, 21} in part
+    True
+    >>> {2, 8, 9, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33} in part
+    True
+
+    See Also
+    --------
+    edge_current_flow_betweenness_partition
+
+    Notes
+    -----
+    This algorithm is fairly slow, as both the calculation of connected
+    components and edge betweenness relies on all pairs shortest
+    path algorithms. They could potentially be combined to cut down
+    on overall computation time.
+
+    References
+    ----------
+    .. [1] Santo Fortunato 'Community Detection in Graphs' Physical Reports
+       Volume 486, Issue 3-5 p. 75-174
+       http://arxiv.org/abs/0906.0612
+    """
+    if number_of_sets <= 0:
+        raise nx.NetworkXError("number_of_sets must be >0")
+    if number_of_sets == 1:
+        return [set(G)]
+    if number_of_sets == len(G):
+        return [{n} for n in G]
+    if number_of_sets > len(G):
+        raise nx.NetworkXError("number_of_sets must be <= len(G)")
+
+    H = G.copy()
+    partition = list(nx.connected_components(H))
+    while len(partition) < number_of_sets:
+        ranking = nx.edge_betweenness_centrality(H, weight=weight)
+        edge = max(ranking, key=ranking.get)
+        H.remove_edge(*edge)
+        partition = list(nx.connected_components(H))
+    return partition
+
+
+def edge_current_flow_betweenness_partition(G, number_of_sets, *, weight=None):
+    """Partition created by removing the highest edge current flow betweenness edge.
+
+    This algorithm works by calculating the edge current flow
+    betweenness for all edges and removing the edge with the
+    highest value. It is then determined whether the graph has
+    been broken into at least `number_of_sets` connected
+    components. If not the process is repeated.
+
+    Parameters
+    ----------
+    G : NetworkX Graph, DiGraph or MultiGraph
+      Graph to be partitioned
+
+    number_of_sets : int
+      Number of sets in the desired partition of the graph
+
+    weight : key, optional (default=None)
+      The edge attribute key to use as weights for
+      edge current flow betweenness calculations
+
+    Returns
+    -------
+    C : list of sets
+      Partition of G
+
+    Raises
+    ------
+    NetworkXError
+      If number_of_sets is <= 0 or number_of_sets > len(G)
+
+    Examples
+    --------
+    >>> G = nx.karate_club_graph()
+    >>> part = nx.community.edge_current_flow_betweenness_partition(G, 2)
+    >>> {0, 1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 16, 17, 19, 21} in part
+    True
+    >>> {8, 14, 15, 18, 20, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33} in part
+    True
+
+
+    See Also
+    --------
+    edge_betweenness_partition
+
+    Notes
+    -----
+    This algorithm is extremely slow, as the recalculation of the edge
+    current flow betweenness is extremely slow.
+
+    References
+    ----------
+    .. [1] Santo Fortunato 'Community Detection in Graphs' Physical Reports
+       Volume 486, Issue 3-5 p. 75-174
+       http://arxiv.org/abs/0906.0612
+    """
+    if number_of_sets <= 0:
+        raise nx.NetworkXError("number_of_sets must be >0")
+    elif number_of_sets == 1:
+        return [set(G)]
+    elif number_of_sets == len(G):
+        return [{n} for n in G]
+    elif number_of_sets > len(G):
+        raise nx.NetworkXError("number_of_sets must be <= len(G)")
+
+    rank = functools.partial(
+        nx.edge_current_flow_betweenness_centrality, normalized=False, weight=weight
+    )
+
+    # current flow requires a connected network so we track the components explicitly
+    H = G.copy()
+    partition = list(nx.connected_components(H))
+    if len(partition) > 1:
+        Hcc_subgraphs = [H.subgraph(cc).copy() for cc in partition]
+    else:
+        Hcc_subgraphs = [H]
+
+    ranking = {}
+    for Hcc in Hcc_subgraphs:
+        ranking.update(rank(Hcc))
+
+    while len(partition) < number_of_sets:
+        edge = max(ranking, key=ranking.get)
+        for cc, Hcc in zip(partition, Hcc_subgraphs):
+            if edge[0] in cc:
+                Hcc.remove_edge(*edge)
+                del ranking[edge]
+                splitcc_list = list(nx.connected_components(Hcc))
+                if len(splitcc_list) > 1:
+                    # there are 2 connected components. split off smaller one
+                    cc_new = min(splitcc_list, key=len)
+                    Hcc_new = Hcc.subgraph(cc_new).copy()
+                    # update edge rankings for Hcc_new
+                    newranks = rank(Hcc_new)
+                    for e, r in newranks.items():
+                        ranking[e if e in ranking else e[::-1]] = r
+                    # append new cc and Hcc to their lists.
+                    partition.append(cc_new)
+                    Hcc_subgraphs.append(Hcc_new)
+
+                    # leave existing cc and Hcc in their lists, but shrink them
+                    Hcc.remove_nodes_from(cc_new)
+                    cc.difference_update(cc_new)
+                # update edge rankings for Hcc whether it was split or not
+                newranks = rank(Hcc)
+                for e, r in newranks.items():
+                    ranking[e if e in ranking else e[::-1]] = r
+                break
+    return partition
diff --git a/networkx/algorithms/community/tests/test_divisive.py b/networkx/algorithms/community/tests/test_divisive.py
new file mode 100644
index 00000000000..f3857613db2
--- /dev/null
+++ b/networkx/algorithms/community/tests/test_divisive.py
@@ -0,0 +1,109 @@
+import pytest
+
+import networkx as nx
+
+
+def test_edge_betweenness_partition():
+    G = nx.barbell_graph(3, 0)
+    C = nx.community.edge_betweenness_partition(G, 2)
+    answer = [{0, 1, 2}, {3, 4, 5}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    G = nx.barbell_graph(3, 1)
+    C = nx.community.edge_betweenness_partition(G, 3)
+    answer = [{0, 1, 2}, {4, 5, 6}, {3}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_betweenness_partition(G, 7)
+    answer = [{n} for n in G]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_betweenness_partition(G, 1)
+    assert C == [set(G)]
+
+    C = nx.community.edge_betweenness_partition(G, 1, weight="weight")
+    assert C == [set(G)]
+
+    with pytest.raises(nx.NetworkXError):
+        nx.community.edge_betweenness_partition(G, 0)
+
+    with pytest.raises(nx.NetworkXError):
+        nx.community.edge_betweenness_partition(G, -1)
+
+    with pytest.raises(nx.NetworkXError):
+        nx.community.edge_betweenness_partition(G, 10)
+
+
+def test_edge_current_flow_betweenness_partition():
+    pytest.importorskip("numpy")
+
+    G = nx.barbell_graph(3, 0)
+    C = nx.community.edge_current_flow_betweenness_partition(G, 2)
+    answer = [{0, 1, 2}, {3, 4, 5}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    G = nx.barbell_graph(3, 1)
+    C = nx.community.edge_current_flow_betweenness_partition(G, 2)
+    answer = [{0, 1, 2, 3}, {4, 5, 6}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_current_flow_betweenness_partition(G, 3)
+    answer = [{0, 1, 2}, {4, 5, 6}, {3}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_current_flow_betweenness_partition(G, 4)
+    answer = [{1, 2}, {4, 5, 6}, {3}, {0}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_current_flow_betweenness_partition(G, 5)
+    answer = [{1, 2}, {5, 6}, {3}, {0}, {4}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_current_flow_betweenness_partition(G, 6)
+    answer = [{2}, {5, 6}, {3}, {0}, {4}, {1}]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_current_flow_betweenness_partition(G, 7)
+    answer = [{n} for n in G]
+    assert len(C) == len(answer)
+    for s in answer:
+        assert s in C
+
+    C = nx.community.edge_current_flow_betweenness_partition(G, 1)
+    assert C == [set(G)]
+
+    C = nx.community.edge_current_flow_betweenness_partition(G, 1, weight="weight")
+    assert C == [set(G)]
+
+    with pytest.raises(nx.NetworkXError):
+        nx.community.edge_current_flow_betweenness_partition(G, 0)
+
+    with pytest.raises(nx.NetworkXError):
+        nx.community.edge_current_flow_betweenness_partition(G, -1)
+
+    with pytest.raises(nx.NetworkXError):
+        nx.community.edge_current_flow_betweenness_partition(G, 10)
+
+    N = 10
+    G = nx.empty_graph(N)
+    for i in range(2, N - 1):
+        C = nx.community.edge_current_flow_betweenness_partition(G, i)
+        assert C == [{n} for n in G]

From 55ed94797df50f34597e1bde95ab7cd06e4cc2f2 Mon Sep 17 00:00:00 2001
From: Dan Schult <dschult@colgate.edu>
Date: Fri, 19 Jan 2024 18:29:27 -0500
Subject: [PATCH 047/129] add seed to graph creation (#7241)

* add seed to graph creation

* revert binomial_tree as no seed
---
 networkx/algorithms/tests/test_swap.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/networkx/algorithms/tests/test_swap.py b/networkx/algorithms/tests/test_swap.py
index 378c8ecfa61..c4aeb0682e0 100644
--- a/networkx/algorithms/tests/test_swap.py
+++ b/networkx/algorithms/tests/test_swap.py
@@ -3,7 +3,7 @@
 import networkx as nx
 
 cycle = nx.cycle_graph(5, create_using=nx.DiGraph)
-tree = nx.random_tree(10, create_using=nx.DiGraph)
+tree = nx.random_tree(10, create_using=nx.DiGraph, seed=42)
 path = nx.path_graph(5, create_using=nx.DiGraph)
 binomial = nx.binomial_tree(3, create_using=nx.DiGraph)
 HH = nx.directed_havel_hakimi_graph([1, 2, 1, 2, 2, 2], [3, 1, 0, 1, 2, 3])

From 838fc93423acb7969507ac01e0ee3dad0f4153e5 Mon Sep 17 00:00:00 2001
From: Dan Schult <dschult@colgate.edu>
Date: Sat, 20 Jan 2024 09:47:47 -0500
Subject: [PATCH 048/129] add seed to tests of
 fast_label_propatation_communities (#7242)

---
 .../community/tests/test_label_propagation.py         | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/networkx/algorithms/community/tests/test_label_propagation.py b/networkx/algorithms/community/tests/test_label_propagation.py
index 9a0b3d89b6e..d86b1d7d47f 100644
--- a/networkx/algorithms/community/tests/test_label_propagation.py
+++ b/networkx/algorithms/community/tests/test_label_propagation.py
@@ -163,7 +163,7 @@ class TestFastLabelPropagationCommunities:
     N = 100  # number of nodes
     K = 15  # average node degree
 
-    def _check_communities(self, G, truth, weight=None, seed=None):
+    def _check_communities(self, G, truth, weight=None, seed=42):
         C = nx.community.fast_label_propagation_communities(G, weight=weight, seed=seed)
         assert {frozenset(c) for c in C} == truth
 
@@ -203,10 +203,9 @@ def test_disjoin_cliques(self):
         self._check_communities(G, truth)
 
     def test_ring_of_cliques(self):
-        G = nx.ring_of_cliques(self.N, self.K)
-        truth = {
-            frozenset([self.K * i + k for k in range(self.K)]) for i in range(self.N)
-        }
+        N, K = self.N, self.K
+        G = nx.ring_of_cliques(N, K)
+        truth = {frozenset([K * i + k for k in range(K)]) for i in range(N)}
         self._check_communities(G, truth)
 
     def test_larger_graph(self):
@@ -238,3 +237,5 @@ def test_seed_argument(self):
         C = nx.community.fast_label_propagation_communities(G, seed=2023)
         truth = {frozenset(c) for c in C}
         self._check_communities(G, truth, seed=2023)
+        # smoke test that seed=None works
+        C = nx.community.fast_label_propagation_communities(G, seed=None)

From d06bbe06241d6b310b840825053a2bbfa096f994 Mon Sep 17 00:00:00 2001
From: Maximilian Seeliger <maximilian.seeliger@gmail.com>
Date: Wed, 24 Jan 2024 00:28:03 +0100
Subject: [PATCH 049/129] Added feature modular graph product (#7227)

* Implementation of modular product

* Improved performance by reducing number of loops

* Added doc reference and tests

Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 doc/reference/algorithms/operators.rst        |  1 +
 networkx/algorithms/operators/product.py      | 94 +++++++++++++++++++
 .../operators/tests/test_product.py           | 56 +++++++++++
 3 files changed, 151 insertions(+)

diff --git a/doc/reference/algorithms/operators.rst b/doc/reference/algorithms/operators.rst
index 13632e270e6..c97c96c3c10 100644
--- a/doc/reference/algorithms/operators.rst
+++ b/doc/reference/algorithms/operators.rst
@@ -44,3 +44,4 @@ Operators
    tensor_product
    power
    corona_product
+   modular_product
diff --git a/networkx/algorithms/operators/product.py b/networkx/algorithms/operators/product.py
index 3128f82b40b..ee38fd7a18c 100644
--- a/networkx/algorithms/operators/product.py
+++ b/networkx/algorithms/operators/product.py
@@ -14,6 +14,7 @@
     "power",
     "rooted_product",
     "corona_product",
+    "modular_product",
 ]
 _G_H = {"G": 0, "H": 1}
 
@@ -532,3 +533,96 @@ def corona_product(G, H):
         GH.add_edges_from((G_node, (G_node, H_node)) for H_node in H)
 
     return GH
+
+
+@nx._dispatchable(graphs=_G_H)
+def modular_product(G, H):
+    r"""Returns the Modular product of G and H.
+
+    The modular product of `G` and `H` is the graph $M = G \nabla H$,
+    consisting of the node set $V(M) = V(G) \times V(H)$ that is the Cartesian
+    product of the node sets of `G` and `H`. Further, M contains an edge ((u, v), (x, y)):
+
+    - if u is adjacent to x in `G` and v is adjacent to y in `H`, or
+    - if u is not adjacent to x in `G` and v is not adjacent to y in `H`.
+
+    More formally
+    ::
+
+        E(M) = {((u, v), (x, y)) | ((u, x) in E(G) and (v, y) in E(H)) or
+                                   ((u, x) not in E(G) and (v, y) not in E(H))}
+    Parameters
+    ----------
+    G, H: NetworkX graphs
+        The graphs to take the modular product of.
+
+    Returns
+    -------
+    M: NetworkX graph
+        The Modular product of G and H.
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If G is not a simple graph.
+
+    Examples
+    --------
+    >>> G = nx.cycle_graph(4)
+    >>> H = nx.path_graph(2)
+    >>> M = nx.modular_product(G, H)
+    >>> list(M)
+    [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1)]
+    >>> print(M)
+    Graph with 8 nodes and 8 edges
+
+    Notes
+    -----
+    The *modular product* is defined in [1]_ and was first
+    introduced as the *weak modular product*.
+
+    The modular product reduces the problem of counting isomorphic subgraphs
+    in `G` and `H` to the problem of counting cliques in M. The subgraphs of
+    `G` and `H` that are induced by the nodes of a clique in M are
+    isomorphic [2]_ [3]_.
+
+    References
+    ----------
+    .. [1] R. Hammack, W. Imrich, and S. Klavžar,
+        "Handbook of Product Graphs", CRC Press, 2011.
+
+    .. [2] H. G. Barrow and R. M. Burstall,
+        "Subgraph isomorphism, matching relational structures and maximal
+        cliques", Information Processing Letters, vol. 4, issue 4, pp. 83-84,
+        1976, https://doi.org/10.1016/0020-0190(76)90049-1.
+
+    .. [3] V. G. Vizing, "Reduction of the problem of isomorphism and isomorphic
+        entrance to the task of finding the nondensity of a graph." Proc. Third
+        All-Union Conference on Problems of Theoretical Cybernetics. 1974.
+    """
+    if G.is_directed() or H.is_directed():
+        raise nx.NetworkXNotImplemented(
+            "Modular product not implemented for directed graphs"
+        )
+    if G.is_multigraph() or H.is_multigraph():
+        raise nx.NetworkXNotImplemented(
+            "Modular product not implemented for multigraphs"
+        )
+
+    GH = _init_product_graph(G, H)
+    GH.add_nodes_from(_node_product(G, H))
+
+    for u, v, c in G.edges(data=True):
+        for x, y, d in H.edges(data=True):
+            GH.add_edge((u, x), (v, y), **_dict_product(c, d))
+            GH.add_edge((v, x), (u, y), **_dict_product(c, d))
+
+    G = nx.complement(G)
+    H = nx.complement(H)
+
+    for u, v, c in G.edges(data=True):
+        for x, y, d in H.edges(data=True):
+            GH.add_edge((u, x), (v, y), **_dict_product(c, d))
+            GH.add_edge((v, x), (u, y), **_dict_product(c, d))
+
+    return GH
diff --git a/networkx/algorithms/operators/tests/test_product.py b/networkx/algorithms/operators/tests/test_product.py
index 50bc7b7e59e..2eb788bc302 100644
--- a/networkx/algorithms/operators/tests/test_product.py
+++ b/networkx/algorithms/operators/tests/test_product.py
@@ -433,3 +433,59 @@ def test_corona_product():
     C = nx.corona_product(G, H)
     assert len(C) == (len(G) * len(H)) + len(G)
     assert C.size() == G.size() + len(G) * H.size() + len(G) * len(H)
+
+
+def test_modular_product():
+    G = nx.path_graph(3)
+    H = nx.path_graph(4)
+    M = nx.modular_product(G, H)
+    assert len(M) == len(G) * len(H)
+
+    assert edges_equal(
+        list(M.edges()),
+        [
+            ((0, 0), (1, 1)),
+            ((0, 0), (2, 2)),
+            ((0, 0), (2, 3)),
+            ((0, 1), (1, 0)),
+            ((0, 1), (1, 2)),
+            ((0, 1), (2, 3)),
+            ((0, 2), (1, 1)),
+            ((0, 2), (1, 3)),
+            ((0, 2), (2, 0)),
+            ((0, 3), (1, 2)),
+            ((0, 3), (2, 0)),
+            ((0, 3), (2, 1)),
+            ((1, 0), (2, 1)),
+            ((1, 1), (2, 0)),
+            ((1, 1), (2, 2)),
+            ((1, 2), (2, 1)),
+            ((1, 2), (2, 3)),
+            ((1, 3), (2, 2)),
+        ],
+    )
+
+
+def test_modular_product_raises():
+    G = nx.Graph([(0, 1), (1, 2), (2, 0)])
+    H = nx.Graph([(0, 1), (1, 2), (2, 0)])
+    DG = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
+    DH = nx.DiGraph([(0, 1), (1, 2), (2, 0)])
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.modular_product(G, DH)
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.modular_product(DG, H)
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.modular_product(DG, DH)
+
+    MG = nx.MultiGraph([(0, 1), (1, 2), (2, 0), (0, 1)])
+    MH = nx.MultiGraph([(0, 1), (1, 2), (2, 0), (0, 1)])
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.modular_product(G, MH)
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.modular_product(MG, H)
+    with pytest.raises(nx.NetworkXNotImplemented):
+        nx.modular_product(MG, MH)
+    with pytest.raises(nx.NetworkXNotImplemented):
+        # check multigraph with no multiedges
+        nx.modular_product(nx.MultiGraph(G), H)

From d6569adf7c224a9c85c0e4e4c92435f772f73582 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Wed, 24 Jan 2024 23:39:47 +0530
Subject: [PATCH 050/129] ENH : added `sort_neighbors` to all functions in
 `depth_first_search.py` (#7196)

Added sort_children to all dfs funcs, added dfs tests, updated links in docs of dfs.

Also updated the parameter description for sort_neighbors in all traversal
functions that support it



---------

Co-authored-by: Ross Barnowski <rossbar@caltech.edu>
---
 .../traversal/breadth_first_search.py         |  39 ++++---
 .../traversal/depth_first_search.py           | 109 ++++++++++++++----
 .../algorithms/traversal/tests/test_dfs.py    |  54 +++++++++
 3 files changed, 159 insertions(+), 43 deletions(-)

diff --git a/networkx/algorithms/traversal/breadth_first_search.py b/networkx/algorithms/traversal/breadth_first_search.py
index 09bc695759a..a4e5c951727 100644
--- a/networkx/algorithms/traversal/breadth_first_search.py
+++ b/networkx/algorithms/traversal/breadth_first_search.py
@@ -1,5 +1,4 @@
 """Basic algorithms for breadth-first searching the nodes of a graph."""
-import math
 from collections import deque
 
 import networkx as nx
@@ -44,7 +43,7 @@ def generic_bfs_edges(G, source, neighbors=None, depth_limit=None, sort_neighbor
     depth_limit : int, optional(default=len(G))
         Specify the maximum search depth.
 
-    sort_neighbors : Callable
+    sort_neighbors : Callable (default=None)
 
         .. deprecated:: 3.2
 
@@ -52,9 +51,9 @@ def generic_bfs_edges(G, source, neighbors=None, depth_limit=None, sort_neighbor
            version 3.4. A custom (e.g. sorted) ordering of neighbors can be
            specified with the `neighbors` parameter.
 
-        A function that takes the list of neighbors of a given node as input,
-        and returns an iterator over these neighbors but with a custom
-        ordering.
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
 
     Yields
     ------
@@ -149,9 +148,10 @@ def bfs_edges(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
     depth_limit : int, optional(default=len(G))
         Specify the maximum search depth
 
-    sort_neighbors : function
-        A function that takes the list of neighbors of given node as input, and
-        returns an *iterator* over these neighbors but with custom ordering.
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
 
     Yields
     ------
@@ -210,7 +210,7 @@ def bfs_edges(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
     else:
         successors = G.neighbors
 
-    if callable(sort_neighbors):
+    if sort_neighbors is not None:
         yield from generic_bfs_edges(
             G, source, lambda node: iter(sort_neighbors(successors(node))), depth_limit
         )
@@ -236,9 +236,10 @@ def bfs_tree(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
     depth_limit : int, optional(default=len(G))
         Specify the maximum search depth
 
-    sort_neighbors : function
-        A function that takes the list of neighbors of given node as input, and
-        returns an *iterator* over these neighbors but with custom ordering.
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
 
     Returns
     -------
@@ -299,9 +300,10 @@ def bfs_predecessors(G, source, depth_limit=None, sort_neighbors=None):
     depth_limit : int, optional(default=len(G))
         Specify the maximum search depth
 
-    sort_neighbors : function
-        A function that takes the list of neighbors of given node as input, and
-        returns an *iterator* over these neighbors but with custom ordering.
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
 
     Returns
     -------
@@ -364,9 +366,10 @@ def bfs_successors(G, source, depth_limit=None, sort_neighbors=None):
     depth_limit : int, optional(default=len(G))
         Specify the maximum search depth
 
-    sort_neighbors : function
-        A function that takes the list of neighbors of given node as input, and
-        returns an *iterator* over these neighbors but with custom ordering.
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
 
     Returns
     -------
diff --git a/networkx/algorithms/traversal/depth_first_search.py b/networkx/algorithms/traversal/depth_first_search.py
index 843a793aed6..8a06a96c7ac 100644
--- a/networkx/algorithms/traversal/depth_first_search.py
+++ b/networkx/algorithms/traversal/depth_first_search.py
@@ -15,7 +15,7 @@
 
 
 @nx._dispatchable
-def dfs_edges(G, source=None, depth_limit=None):
+def dfs_edges(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Iterate over edges in a depth-first-search (DFS).
 
     Perform a depth-first-search over the nodes of `G` and yield
@@ -33,6 +33,11 @@ def dfs_edges(G, source=None, depth_limit=None):
     depth_limit : int, optional (default=len(G))
        Specify the maximum search depth.
 
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
+
     Yields
     ------
     edge: 2-tuple of nodes
@@ -78,12 +83,18 @@ def dfs_edges(G, source=None, depth_limit=None):
     if depth_limit is None:
         depth_limit = len(G)
 
+    get_children = (
+        G.neighbors
+        if sort_neighbors is None
+        else lambda n: iter(sort_neighbors(G.neighbors(n)))
+    )
+
     visited = set()
     for start in nodes:
         if start in visited:
             continue
         visited.add(start)
-        stack = [(start, iter(G[start]))]
+        stack = [(start, get_children(start))]
         depth_now = 1
         while stack:
             parent, children = stack[-1]
@@ -92,7 +103,7 @@ def dfs_edges(G, source=None, depth_limit=None):
                     yield parent, child
                     visited.add(child)
                     if depth_now < depth_limit:
-                        stack.append((child, iter(G[child])))
+                        stack.append((child, get_children(child)))
                         depth_now += 1
                         break
             else:
@@ -101,7 +112,7 @@ def dfs_edges(G, source=None, depth_limit=None):
 
 
 @nx._dispatchable
-def dfs_tree(G, source=None, depth_limit=None):
+def dfs_tree(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Returns oriented tree constructed from a depth-first-search from source.
 
     Parameters
@@ -114,6 +125,11 @@ def dfs_tree(G, source=None, depth_limit=None):
     depth_limit : int, optional (default=len(G))
        Specify the maximum search depth.
 
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
+
     Returns
     -------
     T : NetworkX DiGraph
@@ -134,20 +150,20 @@ def dfs_tree(G, source=None, depth_limit=None):
     dfs_preorder_nodes
     dfs_postorder_nodes
     dfs_labeled_edges
-    edge_dfs
-    bfs_tree
+    :func:`~networkx.algorithms.traversal.edgedfs.edge_dfs`
+    :func:`~networkx.algorithms.traversal.breadth_first_search.bfs_tree`
     """
     T = nx.DiGraph()
     if source is None:
         T.add_nodes_from(G)
     else:
         T.add_node(source)
-    T.add_edges_from(dfs_edges(G, source, depth_limit))
+    T.add_edges_from(dfs_edges(G, source, depth_limit, sort_neighbors=sort_neighbors))
     return T
 
 
 @nx._dispatchable
-def dfs_predecessors(G, source=None, depth_limit=None):
+def dfs_predecessors(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Returns dictionary of predecessors in depth-first-search from source.
 
     Parameters
@@ -163,6 +179,11 @@ def dfs_predecessors(G, source=None, depth_limit=None):
     depth_limit : int, optional (default=len(G))
        Specify the maximum search depth.
 
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
+
     Returns
     -------
     pred: dict
@@ -194,14 +215,17 @@ def dfs_predecessors(G, source=None, depth_limit=None):
     dfs_preorder_nodes
     dfs_postorder_nodes
     dfs_labeled_edges
-    edge_dfs
-    bfs_tree
+    :func:`~networkx.algorithms.traversal.edgedfs.edge_dfs`
+    :func:`~networkx.algorithms.traversal.breadth_first_search.bfs_tree`
     """
-    return {t: s for s, t in dfs_edges(G, source, depth_limit)}
+    return {
+        t: s
+        for s, t in dfs_edges(G, source, depth_limit, sort_neighbors=sort_neighbors)
+    }
 
 
 @nx._dispatchable
-def dfs_successors(G, source=None, depth_limit=None):
+def dfs_successors(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Returns dictionary of successors in depth-first-search from source.
 
     Parameters
@@ -217,6 +241,11 @@ def dfs_successors(G, source=None, depth_limit=None):
     depth_limit : int, optional (default=len(G))
        Specify the maximum search depth.
 
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
+
     Returns
     -------
     succ: dict
@@ -248,17 +277,22 @@ def dfs_successors(G, source=None, depth_limit=None):
     dfs_preorder_nodes
     dfs_postorder_nodes
     dfs_labeled_edges
-    edge_dfs
-    bfs_tree
+    :func:`~networkx.algorithms.traversal.edgedfs.edge_dfs`
+    :func:`~networkx.algorithms.traversal.breadth_first_search.bfs_tree`
     """
     d = defaultdict(list)
-    for s, t in dfs_edges(G, source=source, depth_limit=depth_limit):
+    for s, t in dfs_edges(
+        G,
+        source=source,
+        depth_limit=depth_limit,
+        sort_neighbors=sort_neighbors,
+    ):
         d[s].append(t)
     return dict(d)
 
 
 @nx._dispatchable
-def dfs_postorder_nodes(G, source=None, depth_limit=None):
+def dfs_postorder_nodes(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Generate nodes in a depth-first-search post-ordering starting at source.
 
     Parameters
@@ -271,6 +305,11 @@ def dfs_postorder_nodes(G, source=None, depth_limit=None):
     depth_limit : int, optional (default=len(G))
        Specify the maximum search depth.
 
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
+
     Returns
     -------
     nodes: generator
@@ -302,15 +341,17 @@ def dfs_postorder_nodes(G, source=None, depth_limit=None):
     dfs_edges
     dfs_preorder_nodes
     dfs_labeled_edges
-    edge_dfs
-    bfs_tree
+    :func:`~networkx.algorithms.traversal.edgedfs.edge_dfs`
+    :func:`~networkx.algorithms.traversal.breadth_first_search.bfs_tree`
     """
-    edges = nx.dfs_labeled_edges(G, source=source, depth_limit=depth_limit)
+    edges = nx.dfs_labeled_edges(
+        G, source=source, depth_limit=depth_limit, sort_neighbors=sort_neighbors
+    )
     return (v for u, v, d in edges if d == "reverse")
 
 
 @nx._dispatchable
-def dfs_preorder_nodes(G, source=None, depth_limit=None):
+def dfs_preorder_nodes(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Generate nodes in a depth-first-search pre-ordering starting at source.
 
     Parameters
@@ -324,6 +365,11 @@ def dfs_preorder_nodes(G, source=None, depth_limit=None):
     depth_limit : int, optional (default=len(G))
        Specify the maximum search depth.
 
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
+
     Returns
     -------
     nodes: generator
@@ -355,14 +401,16 @@ def dfs_preorder_nodes(G, source=None, depth_limit=None):
     dfs_edges
     dfs_postorder_nodes
     dfs_labeled_edges
-    bfs_edges
+    :func:`~networkx.algorithms.traversal.breadth_first_search.bfs_edges`
     """
-    edges = nx.dfs_labeled_edges(G, source=source, depth_limit=depth_limit)
+    edges = nx.dfs_labeled_edges(
+        G, source=source, depth_limit=depth_limit, sort_neighbors=sort_neighbors
+    )
     return (v for u, v, d in edges if d == "forward")
 
 
 @nx._dispatchable
-def dfs_labeled_edges(G, source=None, depth_limit=None):
+def dfs_labeled_edges(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Iterate over edges in a depth-first-search (DFS) labeled by type.
 
     Parameters
@@ -376,6 +424,11 @@ def dfs_labeled_edges(G, source=None, depth_limit=None):
     depth_limit : int, optional (default=len(G))
        Specify the maximum search depth.
 
+    sort_neighbors : function (default=None)
+        A function that takes an iterator over nodes as the input, and
+        returns an iterable of the same nodes with a custom ordering.
+        For example, `sorted` will sort the nodes in increasing order.
+
     Returns
     -------
     edges: generator
@@ -439,13 +492,19 @@ def dfs_labeled_edges(G, source=None, depth_limit=None):
     if depth_limit is None:
         depth_limit = len(G)
 
+    get_children = (
+        G.neighbors
+        if sort_neighbors is None
+        else lambda n: iter(sort_neighbors(G.neighbors(n)))
+    )
+
     visited = set()
     for start in nodes:
         if start in visited:
             continue
         yield start, start, "forward"
         visited.add(start)
-        stack = [(start, iter(G[start]))]
+        stack = [(start, get_children(start))]
         depth_now = 1
         while stack:
             parent, children = stack[-1]
@@ -456,7 +515,7 @@ def dfs_labeled_edges(G, source=None, depth_limit=None):
                     yield parent, child, "forward"
                     visited.add(child)
                     if depth_now < depth_limit:
-                        stack.append((child, iter(G[child])))
+                        stack.append((child, iter(get_children(child))))
                         depth_now += 1
                         break
                     else:
diff --git a/networkx/algorithms/traversal/tests/test_dfs.py b/networkx/algorithms/traversal/tests/test_dfs.py
index 0eb698b0f2d..e43d7d61629 100644
--- a/networkx/algorithms/traversal/tests/test_dfs.py
+++ b/networkx/algorithms/traversal/tests/test_dfs.py
@@ -55,6 +55,14 @@ def test_dfs_edges(self):
         edges = nx.dfs_edges(self.D)
         assert list(edges) == [(0, 1), (2, 3)]
 
+    def test_dfs_edges_sorting(self):
+        G = nx.Graph([(0, 1), (1, 2), (1, 3), (2, 4), (3, 0), (0, 4)])
+        edges_asc = nx.dfs_edges(G, source=0, sort_neighbors=sorted)
+        sorted_desc = lambda x: sorted(x, reverse=True)
+        edges_desc = nx.dfs_edges(G, source=0, sort_neighbors=sorted_desc)
+        assert list(edges_asc) == [(0, 1), (1, 2), (2, 4), (1, 3)]
+        assert list(edges_desc) == [(0, 4), (4, 2), (2, 1), (1, 3)]
+
     def test_dfs_labeled_edges(self):
         edges = list(nx.dfs_labeled_edges(self.G, source=0))
         forward = [(u, v) for (u, v, d) in edges if d == "forward"]
@@ -80,6 +88,52 @@ def test_dfs_labeled_edges(self):
             (0, 0, "reverse"),
         ]
 
+    def test_dfs_labeled_edges_sorting(self):
+        G = nx.Graph([(0, 1), (1, 2), (1, 3), (2, 4), (3, 0), (0, 4)])
+        edges_asc = nx.dfs_labeled_edges(G, source=0, sort_neighbors=sorted)
+        sorted_desc = lambda x: sorted(x, reverse=True)
+        edges_desc = nx.dfs_labeled_edges(G, source=0, sort_neighbors=sorted_desc)
+        assert list(edges_asc) == [
+            (0, 0, "forward"),
+            (0, 1, "forward"),
+            (1, 0, "nontree"),
+            (1, 2, "forward"),
+            (2, 1, "nontree"),
+            (2, 4, "forward"),
+            (4, 0, "nontree"),
+            (4, 2, "nontree"),
+            (2, 4, "reverse"),
+            (1, 2, "reverse"),
+            (1, 3, "forward"),
+            (3, 0, "nontree"),
+            (3, 1, "nontree"),
+            (1, 3, "reverse"),
+            (0, 1, "reverse"),
+            (0, 3, "nontree"),
+            (0, 4, "nontree"),
+            (0, 0, "reverse"),
+        ]
+        assert list(edges_desc) == [
+            (0, 0, "forward"),
+            (0, 4, "forward"),
+            (4, 2, "forward"),
+            (2, 4, "nontree"),
+            (2, 1, "forward"),
+            (1, 3, "forward"),
+            (3, 1, "nontree"),
+            (3, 0, "nontree"),
+            (1, 3, "reverse"),
+            (1, 2, "nontree"),
+            (1, 0, "nontree"),
+            (2, 1, "reverse"),
+            (4, 2, "reverse"),
+            (4, 0, "nontree"),
+            (0, 4, "reverse"),
+            (0, 3, "nontree"),
+            (0, 1, "nontree"),
+            (0, 0, "reverse"),
+        ]
+
     def test_dfs_labeled_disconnected_edges(self):
         edges = list(nx.dfs_labeled_edges(self.D))
         forward = [(u, v) for (u, v, d) in edges if d == "forward"]

From 2da36864c5899cbc55fc98c96635390dd96d5f88 Mon Sep 17 00:00:00 2001
From: William Zijie Zhang <89562186+Transurgeon@users.noreply.github.com>
Date: Mon, 29 Jan 2024 13:58:12 -0500
Subject: [PATCH 051/129] Add Kneser graph creation function (#7146)

Adds the kneser_graph graph generation function.

Co-authored-by: Transurgeon <peter.zijie@gmail.com>
Co-authored-by: Ross Barnowski <rossbar@caltech.edu>
---
 doc/reference/generators.rst              |  1 +
 networkx/generators/classic.py            | 48 +++++++++++++++++++++++
 networkx/generators/tests/test_classic.py | 16 ++++++++
 3 files changed, 65 insertions(+)

diff --git a/doc/reference/generators.rst b/doc/reference/generators.rst
index 14fbb594847..d3b980fec92 100644
--- a/doc/reference/generators.rst
+++ b/doc/reference/generators.rst
@@ -34,6 +34,7 @@ Classic
    dorogovtsev_goltsev_mendes_graph
    empty_graph
    full_rary_tree
+   kneser_graph
    ladder_graph
    lollipop_graph
    null_graph
diff --git a/networkx/generators/classic.py b/networkx/generators/classic.py
index e220f82d8fd..14ed49ecbdb 100644
--- a/networkx/generators/classic.py
+++ b/networkx/generators/classic.py
@@ -30,6 +30,7 @@
     "dorogovtsev_goltsev_mendes_graph",
     "empty_graph",
     "full_rary_tree",
+    "kneser_graph",
     "ladder_graph",
     "lollipop_graph",
     "null_graph",
@@ -103,6 +104,53 @@ def full_rary_tree(r, n, create_using=None):
     return G
 
 
+@nx._dispatchable(graphs=None)
+def kneser_graph(n, k):
+    """Returns the Kneser Graph with parameters `n` and `k`.
+
+    The Kneser Graph has nodes that are k-tuples (subsets) of the integers
+    between 0 and ``n-1``. Nodes are adjacent if their corresponding sets are disjoint.
+
+    Parameters
+    ----------
+    n: int
+        Number of integers from which to make node subsets.
+        Subsets are drawn from ``set(range(n))``.
+    k: int
+        Size of the subsets.
+
+    Returns
+    -------
+    G : NetworkX Graph
+
+    Examples
+    --------
+    >>> G = nx.kneser_graph(5, 2)
+    >>> G.number_of_nodes()
+    10
+    >>> G.number_of_edges()
+    15
+    >>> nx.is_isomorphic(G, nx.petersen_graph())
+    True
+    """
+    if n <= 0:
+        raise NetworkXError("n should be greater than zero")
+    if k <= 0 or k > n:
+        raise NetworkXError("k should be greater than zero and smaller than n")
+
+    G = nx.Graph()
+    # Create all k-subsets of [0, 1, ..., n-1]
+    subsets = list(itertools.combinations(range(n), k))
+
+    if 2 * k > n:
+        G.add_nodes_from(subsets)
+
+    universe = set(range(n))
+    comb = itertools.combinations  # only to make it all fit on one line
+    G.add_edges_from((s, t) for s in subsets for t in comb(universe - set(s), k))
+    return G
+
+
 @nx._dispatchable(graphs=None)
 def balanced_tree(r, h, create_using=None):
     """Returns the perfectly balanced `r`-ary tree of height `h`.
diff --git a/networkx/generators/tests/test_classic.py b/networkx/generators/tests/test_classic.py
index 5e24c7779e2..cf03d3ea707 100644
--- a/networkx/generators/tests/test_classic.py
+++ b/networkx/generators/tests/test_classic.py
@@ -617,3 +617,19 @@ def test_complete_multipartite_graph(self):
                 assert G.nodes[u] != G.nodes[v]
         with pytest.raises(nx.NetworkXError, match="Negative number of nodes"):
             nx.complete_multipartite_graph(2, -3, 4)
+
+    def test_kneser_graph(self):
+        # the petersen graph is a special case of the kneser graph when n=5 and k=2
+        assert is_isomorphic(nx.kneser_graph(5, 2), nx.petersen_graph())
+
+        # when k is 1, the kneser graph returns a complete graph with n vertices
+        for i in range(1, 7):
+            assert is_isomorphic(nx.kneser_graph(i, 1), nx.complete_graph(i))
+
+        # the kneser graph of n and n-1 is the empty graph with n vertices
+        for j in range(3, 7):
+            assert is_isomorphic(nx.kneser_graph(j, j - 1), nx.empty_graph(j))
+
+        # in general the number of edges of the kneser graph is equal to
+        # (n choose k) times (n-k choose k) divided by 2
+        assert nx.number_of_edges(nx.kneser_graph(8, 3)) == 280

From 30ac7956569cb0c4f0787600f8537425d05c5dca Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Mon, 29 Jan 2024 16:45:41 -0800
Subject: [PATCH 052/129] Update general_k_edge_subgraphs docstring. (#7254)

---
 .../connectivity/edge_kcomponents.py          | 25 ++++++++++++-------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/networkx/algorithms/connectivity/edge_kcomponents.py b/networkx/algorithms/connectivity/edge_kcomponents.py
index d2ed1ac5c7d..9dcdf71a2e5 100644
--- a/networkx/algorithms/connectivity/edge_kcomponents.py
+++ b/networkx/algorithms/connectivity/edge_kcomponents.py
@@ -505,17 +505,24 @@ def _high_degree_components(G, k):
 
 @nx._dispatchable
 def general_k_edge_subgraphs(G, k):
-    """General algorithm to find all maximal k-edge-connected subgraphs in G.
+    """General algorithm to find all maximal k-edge-connected subgraphs in `G`.
 
-    Returns
-    -------
-    k_edge_subgraphs : a generator of nx.Graphs that are k-edge-subgraphs
-        Each k-edge-subgraph is a maximal set of nodes that defines a subgraph
-        of G that is k-edge-connected.
+    Parameters
+    ----------
+    G : nx.Graph
+       Graph in which all maximal k-edge-connected subgraphs will be found.
+
+    k : int
+
+    Yields
+    ------
+    k_edge_subgraphs : Graph instances that are k-edge-subgraphs
+        Each k-edge-subgraph contains a maximal set of nodes that defines a
+        subgraph of `G` that is k-edge-connected.
 
     Notes
     -----
-    Implementation of the basic algorithm from _[1].  The basic idea is to find
+    Implementation of the basic algorithm from [1]_.  The basic idea is to find
     a global minimum cut of the graph. If the cut value is at least k, then the
     graph is a k-edge-connected subgraph and can be added to the results.
     Otherwise, the cut is used to split the graph in two and the procedure is
@@ -524,7 +531,7 @@ def general_k_edge_subgraphs(G, k):
     a single node or a subgraph of G that is k-edge-connected.
 
     This implementation contains optimizations for reducing the number of calls
-    to max-flow, but there are other optimizations in _[1] that could be
+    to max-flow, but there are other optimizations in [1]_ that could be
     implemented.
 
     References
@@ -547,7 +554,7 @@ def general_k_edge_subgraphs(G, k):
     ...     (14, 101, 24),
     ... ]
     >>> G = nx.Graph(it.chain(*[pairwise(path) for path in paths]))
-    >>> sorted(map(len, k_edge_subgraphs(G, k=3)))
+    >>> sorted(len(k_sg) for k_sg in k_edge_subgraphs(G, k=3))
     [1, 1, 1, 4, 4]
     """
     if k < 1:

From f488d0862a33b921f000b501c7c5dec10ea2474e Mon Sep 17 00:00:00 2001
From: Vanshika Mishra <74042272+vanshika230@users.noreply.github.com>
Date: Wed, 31 Jan 2024 22:38:22 +0530
Subject: [PATCH 053/129] Improving test coverage for Small.py (#7260)

* Improving test coverage for Small.py

* Changes required

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>

---------

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 networkx/generators/tests/test_small.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/networkx/generators/tests/test_small.py b/networkx/generators/tests/test_small.py
index 836cbce443c..355d6d36af5 100644
--- a/networkx/generators/tests/test_small.py
+++ b/networkx/generators/tests/test_small.py
@@ -34,6 +34,9 @@ def test__LCF_graph(self):
         utility_graph = nx.complete_bipartite_graph(3, 3)
         assert is_isomorphic(G, utility_graph)
 
+        with pytest.raises(nx.NetworkXError, match="Directed Graph not supported"):
+            G = nx.LCF_graph(6, [3, -3], 3, create_using=nx.DiGraph)
+
     def test_properties_named_small_graphs(self):
         G = nx.bull_graph()
         assert sorted(G) == list(range(5))

From 215470ae23a3f39b2c73da307260819921635921 Mon Sep 17 00:00:00 2001
From: Nihal John George <31016048+nihalgeorge01@users.noreply.github.com>
Date: Wed, 31 Jan 2024 12:48:56 -0500
Subject: [PATCH 054/129] Fix rich_club_coefficient() for small graphs (#7212)

* Improves nx.degree_histogram for empty graph corner case:
   return empty list instead of raising exception
* Fix rich_club_coefficient for graphs with fewer than four nodes, where
   normalization is not possible

---------

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 networkx/algorithms/richclub.py            | 17 +++++++
 networkx/algorithms/tests/test_richclub.py | 52 ++++++++++++++++++++++
 networkx/classes/function.py               |  2 +-
 networkx/classes/tests/test_function.py    |  5 +++
 4 files changed, 75 insertions(+), 1 deletion(-)

diff --git a/networkx/algorithms/richclub.py b/networkx/algorithms/richclub.py
index f787f4254bf..445b27d1425 100644
--- a/networkx/algorithms/richclub.py
+++ b/networkx/algorithms/richclub.py
@@ -44,6 +44,12 @@ def rich_club_coefficient(G, normalized=True, Q=100, seed=None):
     rc : dictionary
        A dictionary, keyed by degree, with rich-club coefficient values.
 
+    Raises
+    ------
+    NetworkXError
+        If `G` has fewer than four nodes and ``normalized=True``.
+        A randomly sampled graph for normalization cannot be generated in this case.
+
     Examples
     --------
     >>> G = nx.Graph([(0, 1), (0, 2), (1, 2), (1, 3), (1, 4), (4, 5)])
@@ -57,6 +63,14 @@ def rich_club_coefficient(G, normalized=True, Q=100, seed=None):
     algorithm ignores any edge weights and is not defined for directed
     graphs or graphs with parallel edges or self loops.
 
+    Normalization is done by computing the rich club coefficient for a randomly
+    sampled graph with the same degree distribution as `G` by
+    repeatedly swapping the endpoints of existing edges. For graphs with fewer than 4
+    nodes, it is not possible to generate a random graph with a prescribed
+    degree distribution, as the degree distribution fully determines the graph
+    (hence making the coefficients trivially normalized to 1).
+    This function raises an exception in this case.
+
     Estimates for appropriate values of `Q` are found in [2]_.
 
     References
@@ -108,6 +122,9 @@ def _compute_rc(G):
     # side of the list, which would have a linear time cost.
     edge_degrees = sorted((sorted(map(G.degree, e)) for e in G.edges()), reverse=True)
     ek = G.number_of_edges()
+    if ek == 0:
+        return {}
+
     k1, k2 = edge_degrees.pop()
     rc = {}
     for d, nk in enumerate(nks):
diff --git a/networkx/algorithms/tests/test_richclub.py b/networkx/algorithms/tests/test_richclub.py
index 5638ddbf007..8d83abaea18 100644
--- a/networkx/algorithms/tests/test_richclub.py
+++ b/networkx/algorithms/tests/test_richclub.py
@@ -91,6 +91,58 @@ def test_rich_club_selfloop():
         nx.rich_club_coefficient(G)
 
 
+def test_rich_club_leq_3_nodes_unnormalized():
+    # edgeless graphs upto 3 nodes
+    G = nx.Graph()
+    rc = nx.rich_club_coefficient(G, normalized=False)
+    assert rc == {}
+
+    for i in range(3):
+        G.add_node(i)
+        rc = nx.rich_club_coefficient(G, normalized=False)
+        assert rc == {}
+
+    # 2 nodes, single edge
+    G = nx.Graph()
+    G.add_edge(0, 1)
+    rc = nx.rich_club_coefficient(G, normalized=False)
+    assert rc == {0: 1}
+
+    # 3 nodes, single edge
+    G = nx.Graph()
+    G.add_nodes_from([0, 1, 2])
+    G.add_edge(0, 1)
+    rc = nx.rich_club_coefficient(G, normalized=False)
+    assert rc == {0: 1}
+
+    # 3 nodes, 2 edges
+    G.add_edge(1, 2)
+    rc = nx.rich_club_coefficient(G, normalized=False)
+    assert rc == {0: 2 / 3}
+
+    # 3 nodes, 3 edges
+    G.add_edge(0, 2)
+    rc = nx.rich_club_coefficient(G, normalized=False)
+    assert rc == {0: 1, 1: 1}
+
+
+def test_rich_club_leq_3_nodes_normalized():
+    G = nx.Graph()
+    with pytest.raises(
+        nx.exception.NetworkXError,
+        match="Graph has fewer than four nodes",
+    ):
+        rc = nx.rich_club_coefficient(G, normalized=True)
+
+    for i in range(3):
+        G.add_node(i)
+        with pytest.raises(
+            nx.exception.NetworkXError,
+            match="Graph has fewer than four nodes",
+        ):
+            rc = nx.rich_club_coefficient(G, normalized=True)
+
+
 # def test_richclub2_normalized():
 #    T = nx.balanced_tree(2,10)
 #    rcNorm = nx.richclub.rich_club_coefficient(T,Q=2)
diff --git a/networkx/classes/function.py b/networkx/classes/function.py
index 2746d56d715..f6bb9a476c2 100644
--- a/networkx/classes/function.py
+++ b/networkx/classes/function.py
@@ -156,7 +156,7 @@ def degree_histogram(G):
     (Order(number_of_edges))
     """
     counts = Counter(d for n, d in G.degree())
-    return [counts.get(i, 0) for i in range(max(counts) + 1)]
+    return [counts.get(i, 0) for i in range(max(counts) + 1 if counts else 0)]
 
 
 def is_directed(G):
diff --git a/networkx/classes/tests/test_function.py b/networkx/classes/tests/test_function.py
index 61b73c2d256..e5596f4fb0c 100644
--- a/networkx/classes/tests/test_function.py
+++ b/networkx/classes/tests/test_function.py
@@ -6,6 +6,11 @@
 from networkx.utils import edges_equal, nodes_equal
 
 
+def test_degree_histogram_empty():
+    G = nx.Graph()
+    assert nx.degree_histogram(G) == []
+
+
 class TestFunction:
     def setup_method(self):
         self.G = nx.Graph({0: [1, 2, 3], 1: [1, 2, 0], 4: []}, name="Test")

From 3bdf3bbf2f34d6cbcac9261ceddb53d0858fe070 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Wed, 31 Jan 2024 23:36:09 +0530
Subject: [PATCH 055/129] Test for symmetric edge flow betweenness partition
 (#7251)

Add more valid partitions to test cases
---
 .../community/tests/test_divisive.py          | 21 ++++++++-----------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/networkx/algorithms/community/tests/test_divisive.py b/networkx/algorithms/community/tests/test_divisive.py
index f3857613db2..874e8c1677b 100644
--- a/networkx/algorithms/community/tests/test_divisive.py
+++ b/networkx/algorithms/community/tests/test_divisive.py
@@ -52,10 +52,9 @@ def test_edge_current_flow_betweenness_partition():
 
     G = nx.barbell_graph(3, 1)
     C = nx.community.edge_current_flow_betweenness_partition(G, 2)
-    answer = [{0, 1, 2, 3}, {4, 5, 6}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
+    answers = [[{0, 1, 2, 3}, {4, 5, 6}], [{0, 1, 2}, {3, 4, 5, 6}]]
+    assert len(C) == len(answers[0])
+    assert any(all(s in answer for s in C) for answer in answers)
 
     C = nx.community.edge_current_flow_betweenness_partition(G, 3)
     answer = [{0, 1, 2}, {4, 5, 6}, {3}]
@@ -64,10 +63,9 @@ def test_edge_current_flow_betweenness_partition():
         assert s in C
 
     C = nx.community.edge_current_flow_betweenness_partition(G, 4)
-    answer = [{1, 2}, {4, 5, 6}, {3}, {0}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
+    answers = [[{1, 2}, {4, 5, 6}, {3}, {0}], [{0, 1, 2}, {5, 6}, {3}, {4}]]
+    assert len(C) == len(answers[0])
+    assert any(all(s in answer for s in C) for answer in answers)
 
     C = nx.community.edge_current_flow_betweenness_partition(G, 5)
     answer = [{1, 2}, {5, 6}, {3}, {0}, {4}]
@@ -76,10 +74,9 @@ def test_edge_current_flow_betweenness_partition():
         assert s in C
 
     C = nx.community.edge_current_flow_betweenness_partition(G, 6)
-    answer = [{2}, {5, 6}, {3}, {0}, {4}, {1}]
-    assert len(C) == len(answer)
-    for s in answer:
-        assert s in C
+    answers = [[{2}, {5, 6}, {3}, {0}, {4}, {1}], [{1, 2}, {6}, {3}, {0}, {4}, {5}]]
+    assert len(C) == len(answers[0])
+    assert any(all(s in answer for s in C) for answer in answers)
 
     C = nx.community.edge_current_flow_betweenness_partition(G, 7)
     answer = [{n} for n in G]

From 7c0d8812d87c851bc646c1f2739a223885a39b6a Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Thu, 1 Feb 2024 23:32:40 +0530
Subject: [PATCH 056/129] MAINT : added `seed` to `gnm_random_graph` in
 `community/tests/test_label_propagation.py` (#7264)

added seed to tests
---
 networkx/algorithms/community/tests/test_label_propagation.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/networkx/algorithms/community/tests/test_label_propagation.py b/networkx/algorithms/community/tests/test_label_propagation.py
index d86b1d7d47f..4be72dbf272 100644
--- a/networkx/algorithms/community/tests/test_label_propagation.py
+++ b/networkx/algorithms/community/tests/test_label_propagation.py
@@ -193,7 +193,7 @@ def test_bipartite_graph(self):
         self._check_communities(G, truth)
 
     def test_random_graph(self):
-        G = nx.gnm_random_graph(self.N, self.N * self.K // 2)
+        G = nx.gnm_random_graph(self.N, self.N * self.K // 2, seed=42)
         truth = {frozenset(G)}
         self._check_communities(G, truth)
 
@@ -209,7 +209,7 @@ def test_ring_of_cliques(self):
         self._check_communities(G, truth)
 
     def test_larger_graph(self):
-        G = nx.gnm_random_graph(100 * self.N, 50 * self.N * self.K)
+        G = nx.gnm_random_graph(100 * self.N, 50 * self.N * self.K, seed=42)
         nx.community.fast_label_propagation_communities(G)
 
     def test_graph_type(self):

From 42666fa19e0ac2a2ba8e074d06c08f971a5d160e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 1 Feb 2024 16:44:56 -0800
Subject: [PATCH 057/129] Bump scientific-python/upload-nightly-action from
 0.2.0 to 0.3.0 (#7266)

Bumps [scientific-python/upload-nightly-action](https://github.com/scientific-python/upload-nightly-action) from 0.2.0 to 0.3.0.
- [Release notes](https://github.com/scientific-python/upload-nightly-action/releases)
- [Commits](https://github.com/scientific-python/upload-nightly-action/compare/5fb764c5bce1ac2297084c0f7161b1919f17c74f...6e9304f7a3a5501c6f98351537493ec898728299)

---
updated-dependencies:
- dependency-name: scientific-python/upload-nightly-action
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/nightly.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index b274f5c7f21..a8bc0c0575f 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -27,7 +27,7 @@ jobs:
       - name: List contents of wheel
         run: python -m zipfile --list dist/networkx-*.whl
       - name: Upload nighlty wheel
-        uses: scientific-python/upload-nightly-action@5fb764c5bce1ac2297084c0f7161b1919f17c74f # 0.2.0
+        uses: scientific-python/upload-nightly-action@6e9304f7a3a5501c6f98351537493ec898728299 # 0.3.0
         with:
           anaconda_nightly_upload_token: ${{ secrets.ANACONDA_NIGHTLY }}
           artifacts_path: dist/

From 72d1f680f60213102df1ab07c5eef82605944594 Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Fri, 2 Feb 2024 14:04:20 +0530
Subject: [PATCH 058/129] ENH: Speed up common/non_neighbors by using _adj dict
 operations (#7244)

* ENH: Speed up common_neighbors by using _adj dict operations

* Speed up non_neighbors

* need for speed

* Update networkx/classes/function.py

Co-authored-by: Dan Schult <dschult@colgate.edu>

* Update networkx/algorithms/link_prediction.py

Co-authored-by: Dan Schult <dschult@colgate.edu>

* Add benchmarks for non_neighbors.

* Add benchmarks for common_neighbors.

---------

Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
Co-authored-by: Ross Barnowski <rossbar@caltech.edu>
---
 benchmarks/benchmarks/benchmark_neighbors.py | 51 ++++++++++++++++++
 networkx/algorithms/link_prediction.py       | 13 +++--
 networkx/classes/function.py                 | 57 ++++++++++----------
 networkx/classes/tests/test_function.py      |  8 +--
 4 files changed, 91 insertions(+), 38 deletions(-)
 create mode 100644 benchmarks/benchmarks/benchmark_neighbors.py

diff --git a/benchmarks/benchmarks/benchmark_neighbors.py b/benchmarks/benchmarks/benchmark_neighbors.py
new file mode 100644
index 00000000000..e821f3cad95
--- /dev/null
+++ b/benchmarks/benchmarks/benchmark_neighbors.py
@@ -0,0 +1,51 @@
+import networkx as nx
+
+
+# NOTE: explicit set construction in benchmarks is required for meaningful
+# comparisons due to change in return type from generator -> set. See gh-7244.
+class NonNeighbors:
+    param_names = ["num_nodes"]
+    params = [10, 100, 1000]
+
+    def setup(self, num_nodes):
+        self.star_graph = nx.star_graph(num_nodes)
+        self.complete_graph = nx.complete_graph(num_nodes)
+        self.path_graph = nx.path_graph(num_nodes)
+
+    def time_star_center(self, num_nodes):
+        set(nx.non_neighbors(self.star_graph, 0))
+
+    def time_star_rim(self, num_nodes):
+        set(nx.non_neighbors(self.star_graph, 5))
+
+    def time_complete(self, num_nodes):
+        set(nx.non_neighbors(self.complete_graph, 0))
+
+    def time_path_first(self, num_nodes):
+        set(nx.non_neighbors(self.path_graph, 0))
+
+    def time_path_last(self, num_nodes):
+        set(nx.non_neighbors(self.path_graph, num_nodes - 1))
+
+    def time_path_center(self, num_nodes):
+        set(nx.non_neighbors(self.path_graph, num_nodes // 2))
+
+
+# NOTE: explicit set construction in benchmarks is required for meaningful
+# comparisons due to change in return type from generator -> set. See gh-7244.
+class CommonNeighbors:
+    param_names = ["num_nodes"]
+    params = [10, 100, 1000]
+
+    def setup(self, num_nodes):
+        self.star_graph = nx.star_graph(num_nodes)
+        self.complete_graph = nx.complete_graph(num_nodes)
+
+    def time_star_center_rim(self, num_nodes):
+        set(nx.common_neighbors(self.star_graph, 0, num_nodes // 2))
+
+    def time_star_rim_rim(self, num_nodes):
+        set(nx.common_neighbors(self.star_graph, 4, 5))
+
+    def time_complete(self, num_nodes):
+        set(nx.common_neighbors(self.complete_graph, 0, num_nodes // 2))
diff --git a/networkx/algorithms/link_prediction.py b/networkx/algorithms/link_prediction.py
index 56f7bc5c1ba..1fb24243a16 100644
--- a/networkx/algorithms/link_prediction.py
+++ b/networkx/algorithms/link_prediction.py
@@ -169,7 +169,7 @@ def predict(u, v):
         union_size = len(set(G[u]) | set(G[v]))
         if union_size == 0:
             return 0
-        return len(list(nx.common_neighbors(G, u, v))) / union_size
+        return len(nx.common_neighbors(G, u, v)) / union_size
 
     return _apply_prediction(G, predict, ebunch)
 
@@ -329,7 +329,7 @@ def predict(u, v):
             if u == v:
                 raise nx.NetworkXAlgorithmError("Self loops are not supported")
 
-            return sum(1 for _ in nx.common_neighbors(G, u, v))
+            return len(nx.common_neighbors(G, u, v))
 
     else:
         spl = dict(nx.shortest_path_length(G))
@@ -340,9 +340,8 @@ def predict(u, v):
                 raise nx.NetworkXAlgorithmError("Self loops are not supported")
             path_len = spl[u].get(v, inf)
 
-            return alpha * sum(1 for _ in nx.common_neighbors(G, u, v)) + (
-                1 - alpha
-            ) * (G.number_of_nodes() / path_len)
+            n_nbrs = len(nx.common_neighbors(G, u, v))
+            return alpha * n_nbrs + (1 - alpha) * len(G) / path_len
 
     return _apply_prediction(G, predict, ebunch)
 
@@ -486,7 +485,7 @@ def cn_soundarajan_hopcroft(G, ebunch=None, community="community"):
     def predict(u, v):
         Cu = _community(G, u, community)
         Cv = _community(G, v, community)
-        cnbors = list(nx.common_neighbors(G, u, v))
+        cnbors = nx.common_neighbors(G, u, v)
         neighbors = (
             sum(_community(G, w, community) == Cu for w in cnbors) if Cu == Cv else 0
         )
@@ -670,7 +669,7 @@ def predict(u, v):
         Cv = _community(G, v, community)
         if Cu != Cv:
             return 0
-        cnbors = set(nx.common_neighbors(G, u, v))
+        cnbors = nx.common_neighbors(G, u, v)
         within = {w for w in cnbors if _community(G, w, community) == Cu}
         inter = cnbors - within
         return len(within) / (len(inter) + delta)
diff --git a/networkx/classes/function.py b/networkx/classes/function.py
index f6bb9a476c2..726b3e23b26 100644
--- a/networkx/classes/function.py
+++ b/networkx/classes/function.py
@@ -809,13 +809,13 @@ def set_edge_attributes(G, values, name=None):
             if G.is_multigraph():
                 for (u, v, key), value in values.items():
                     try:
-                        G[u][v][key][name] = value
+                        G._adj[u][v][key][name] = value
                     except KeyError:
                         pass
             else:
                 for (u, v), value in values.items():
                     try:
-                        G[u][v][name] = value
+                        G._adj[u][v][name] = value
                     except KeyError:
                         pass
         except AttributeError:
@@ -827,13 +827,13 @@ def set_edge_attributes(G, values, name=None):
         if G.is_multigraph():
             for (u, v, key), d in values.items():
                 try:
-                    G[u][v][key].update(d)
+                    G._adj[u][v][key].update(d)
                 except KeyError:
                     pass
         else:
             for (u, v), d in values.items():
                 try:
-                    G[u][v].update(d)
+                    G._adj[u][v].update(d)
                 except KeyError:
                     pass
 
@@ -918,11 +918,10 @@ def non_neighbors(graph, node):
 
     Returns
     -------
-    non_neighbors : iterator
-        Iterator of nodes in the graph that are not neighbors of the node.
+    non_neighbors : set
+        Set of nodes in the graph that are not neighbors of the node.
     """
-    nbors = set(neighbors(graph, node)) | {node}
-    return (nnode for nnode in graph if nnode not in nbors)
+    return graph._adj.keys() - graph._adj[node].keys() - {node}
 
 
 def non_edges(graph):
@@ -964,8 +963,8 @@ def common_neighbors(G, u, v):
 
     Returns
     -------
-    cnbors : iterator
-        Iterator of common neighbors of u and v in the graph.
+    cnbors : set
+        Set of common neighbors of u and v in the graph.
 
     Raises
     ------
@@ -983,9 +982,7 @@ def common_neighbors(G, u, v):
     if v not in G:
         raise nx.NetworkXError("v is not in the graph.")
 
-    # Return a generator explicitly instead of yielding so that the above
-    # checks are executed eagerly.
-    return (w for w in G[u] if w in G[v] and w not in (u, v))
+    return G._adj[u].keys() & G._adj[v].keys() - {u, v}
 
 
 def is_weighted(G, edge=None, weight="weight"):
@@ -1114,7 +1111,7 @@ def is_empty(G):
     is the number of nodes in the graph.
 
     """
-    return not any(G.adj.values())
+    return not any(G._adj.values())
 
 
 def nodes_with_selfloops(G):
@@ -1141,7 +1138,7 @@ def nodes_with_selfloops(G):
     [1]
 
     """
-    return (n for n, nbrs in G.adj.items() if n in nbrs)
+    return (n for n, nbrs in G._adj.items() if n in nbrs)
 
 
 def selfloop_edges(G, data=False, keys=False, default=None):
@@ -1191,56 +1188,59 @@ def selfloop_edges(G, data=False, keys=False, default=None):
             if keys is True:
                 return (
                     (n, n, k, d)
-                    for n, nbrs in G.adj.items()
+                    for n, nbrs in G._adj.items()
                     if n in nbrs
                     for k, d in nbrs[n].items()
                 )
             else:
                 return (
                     (n, n, d)
-                    for n, nbrs in G.adj.items()
+                    for n, nbrs in G._adj.items()
                     if n in nbrs
                     for d in nbrs[n].values()
                 )
         else:
-            return ((n, n, nbrs[n]) for n, nbrs in G.adj.items() if n in nbrs)
+            return ((n, n, nbrs[n]) for n, nbrs in G._adj.items() if n in nbrs)
     elif data is not False:
         if G.is_multigraph():
             if keys is True:
                 return (
                     (n, n, k, d.get(data, default))
-                    for n, nbrs in G.adj.items()
+                    for n, nbrs in G._adj.items()
                     if n in nbrs
                     for k, d in nbrs[n].items()
                 )
             else:
                 return (
                     (n, n, d.get(data, default))
-                    for n, nbrs in G.adj.items()
+                    for n, nbrs in G._adj.items()
                     if n in nbrs
                     for d in nbrs[n].values()
                 )
         else:
             return (
                 (n, n, nbrs[n].get(data, default))
-                for n, nbrs in G.adj.items()
+                for n, nbrs in G._adj.items()
                 if n in nbrs
             )
     else:
         if G.is_multigraph():
             if keys is True:
                 return (
-                    (n, n, k) for n, nbrs in G.adj.items() if n in nbrs for k in nbrs[n]
+                    (n, n, k)
+                    for n, nbrs in G._adj.items()
+                    if n in nbrs
+                    for k in nbrs[n]
                 )
             else:
                 return (
                     (n, n)
-                    for n, nbrs in G.adj.items()
+                    for n, nbrs in G._adj.items()
                     if n in nbrs
                     for i in range(len(nbrs[n]))  # for easy edge removal (#4068)
                 )
         else:
-            return ((n, n) for n, nbrs in G.adj.items() if n in nbrs)
+            return ((n, n) for n, nbrs in G._adj.items() if n in nbrs)
 
 
 def number_of_selfloops(G):
@@ -1288,7 +1288,10 @@ def is_path(G, path):
         True if `path` is a valid path in `G`
 
     """
-    return all((node in G and nbr in G[node]) for node, nbr in nx.utils.pairwise(path))
+    try:
+        return all(nbr in G._adj[node] for node, nbr in nx.utils.pairwise(path))
+    except (KeyError, TypeError):
+        return False
 
 
 def path_weight(G, path, weight):
@@ -1323,7 +1326,7 @@ def path_weight(G, path, weight):
         raise nx.NetworkXNoPath("path does not exist")
     for node, nbr in nx.utils.pairwise(path):
         if multigraph:
-            cost += min(v[weight] for v in G[node][nbr].values())
+            cost += min(v[weight] for v in G._adj[node][nbr].values())
         else:
-            cost += G[node][nbr][weight]
+            cost += G._adj[node][nbr][weight]
     return cost
diff --git a/networkx/classes/tests/test_function.py b/networkx/classes/tests/test_function.py
index e5596f4fb0c..ee4cca8372c 100644
--- a/networkx/classes/tests/test_function.py
+++ b/networkx/classes/tests/test_function.py
@@ -302,13 +302,13 @@ def test_neighbors_complete_graph(self):
     def test_non_neighbors(self):
         graph = nx.complete_graph(100)
         pop = random.sample(list(graph), 1)
-        nbors = list(nx.non_neighbors(graph, pop[0]))
+        nbors = nx.non_neighbors(graph, pop[0])
         # should be all the other vertices in the graph
         assert len(nbors) == 0
 
         graph = nx.path_graph(100)
         node = random.sample(list(graph), 1)[0]
-        nbors = list(nx.non_neighbors(graph, node))
+        nbors = nx.non_neighbors(graph, node)
         # should be all the other vertices in the graph
         if node != 0 and node != 99:
             assert len(nbors) == 97
@@ -317,13 +317,13 @@ def test_non_neighbors(self):
 
         # create a star graph with 99 outer nodes
         graph = nx.star_graph(99)
-        nbors = list(nx.non_neighbors(graph, 0))
+        nbors = nx.non_neighbors(graph, 0)
         assert len(nbors) == 0
 
         # disconnected graph
         graph = nx.Graph()
         graph.add_nodes_from(range(10))
-        nbors = list(nx.non_neighbors(graph, 0))
+        nbors = nx.non_neighbors(graph, 0)
         assert len(nbors) == 9
 
     def test_non_edges(self):

From d769e3b361f5287cc14df8e1d4f1703e2c261217 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Fri, 2 Feb 2024 01:14:08 -0800
Subject: [PATCH 059/129] Update docstring of nonisomorphic_trees. (#7255)

---
 networkx/generators/nonisomorphic_trees.py | 30 ++++++++++------------
 1 file changed, 14 insertions(+), 16 deletions(-)

diff --git a/networkx/generators/nonisomorphic_trees.py b/networkx/generators/nonisomorphic_trees.py
index 6f5d6412361..4389e810a22 100644
--- a/networkx/generators/nonisomorphic_trees.py
+++ b/networkx/generators/nonisomorphic_trees.py
@@ -19,22 +19,20 @@ def nonisomorphic_trees(order, create="graph"):
     Parameters
     ----------
     order : int
-      order of the desired tree(s)
-
-    create : graph or matrix (default="Graph)
-      If graph is selected a list of trees will be returned,
-      if matrix is selected a list of adjacency matrix will
-      be returned
-
-    Returns
-    -------
-    G : List of NetworkX Graphs
-
-    M : List of Adjacency matrices
-
-    References
-    ----------
-
+       order of the desired tree(s)
+
+    create : one of {"graph", "matrix"} (default="graph")
+       If ``"graph"`` is selected a list of ``Graph`` instances will be returned,
+       if matrix is selected a list of adjacency matrices will be returned.
+
+    Yields
+    ------
+    list
+       A list of nonisomorphic trees, in one of two formats depending on the
+       value of the `create` parameter:
+       - ``create="graph"``: yields a list of `networkx.Graph` instances
+       - ``create="matrix"``: yields a list of list-of-lists representing
+         adjacency matrices
     """
 
     if order < 2:

From ea6942ff6f8112d94cfa7fc5ac24eac2b82cce58 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Sun, 4 Feb 2024 04:30:23 +0530
Subject: [PATCH 060/129] adding self loops related docs and tests for
 functions in `cluster.py` (#7261)

* added self-loops notes

* added test_self_loops_square_clustering

* style fix

* style fix
---
 networkx/algorithms/cluster.py            | 6 ++++++
 networkx/algorithms/tests/test_cluster.py | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/networkx/algorithms/cluster.py b/networkx/algorithms/cluster.py
index 35c86daeb58..36e33f0226c 100644
--- a/networkx/algorithms/cluster.py
+++ b/networkx/algorithms/cluster.py
@@ -445,6 +445,10 @@ def transitivity(G):
     out : float
        Transitivity
 
+    Notes
+    -----
+    Self loops are ignored.
+
     Examples
     --------
     >>> G = nx.complete_graph(5)
@@ -581,6 +585,8 @@ def generalized_degree(G, nodes=None):
 
     Notes
     -----
+    Self loops are ignored.
+
     In a network of N nodes, the highest triangle multiplicity an edge can have
     is N-2.
 
diff --git a/networkx/algorithms/tests/test_cluster.py b/networkx/algorithms/tests/test_cluster.py
index d69f036ff6c..b656ba81553 100644
--- a/networkx/algorithms/tests/test_cluster.py
+++ b/networkx/algorithms/tests/test_cluster.py
@@ -457,6 +457,12 @@ def test_peng_square_clustering(self):
         G = nx.Graph([(1, 2), (1, 3), (2, 4), (3, 4), (3, 5), (3, 6)])
         assert nx.square_clustering(G, [1])[1] == 1 / 3
 
+    def test_self_loops_square_clustering(self):
+        G = nx.path_graph(5)
+        assert nx.square_clustering(G) == {0: 0, 1: 0.0, 2: 0.0, 3: 0.0, 4: 0}
+        G.add_edges_from([(0, 0), (1, 1), (2, 2)])
+        assert nx.square_clustering(G) == {0: 1, 1: 0.5, 2: 0.2, 3: 0.0, 4: 0}
+
 
 class TestAverageClustering:
     @classmethod

From 1fa2414f48aae6fb80ad8a2706c8a369b9a05d03 Mon Sep 17 00:00:00 2001
From: "d.grigonis" <dgrigonis@users.noreply.github.com>
Date: Tue, 6 Feb 2024 20:06:44 +0200
Subject: [PATCH 061/129] Add feature for drawing multi edges and labels
 (#7010)

Adds drawing of multiedges and edge labels for multigraphs.
Multiedge styles are specified using connectionstyle and fully
support a subset of simple matplotlib curve-patch styles (i.e.
3-point arc).

Includes significant reorganization of FancyArrowPatch generation.

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 examples/drawing/plot_multigraphs.py |  70 +++
 networkx/drawing/nx_pylab.py         | 728 ++++++++++++++++++---------
 networkx/drawing/tests/test_pylab.py |  60 ++-
 3 files changed, 607 insertions(+), 251 deletions(-)
 create mode 100644 examples/drawing/plot_multigraphs.py

diff --git a/examples/drawing/plot_multigraphs.py b/examples/drawing/plot_multigraphs.py
new file mode 100644
index 00000000000..31886de568a
--- /dev/null
+++ b/examples/drawing/plot_multigraphs.py
@@ -0,0 +1,70 @@
+"""
+======================================
+Plotting MultiDiGraph Edges and Labels
+======================================
+
+This example shows how to plot edges and labels for a MultiDiGraph class object.
+The same applies for DiGraph and MultiGraph class objects.
+
+4 Graphs are created, each with different number of edges between 2 nodes.
+The final graph contains 4 edges in every node pair and 2 self loops per node.
+
+MultiGraph can have unlimited multi-edges that can be drawn
+with different angles and theoretically node labels can remain visible.
+
+Multi-self-loops can be drawn in 4 directions of the node.
+The subsequent loops will result in overlaps.
+"""
+import itertools as it
+import numpy as np
+import networkx as nx
+import matplotlib.pyplot as plt
+
+
+def draw_labeled_multigraph(G, attr_name, ax=None):
+    """
+    Length of connectionstyle must be at least that of a maximum number of edges
+    between pair of nodes. This number is maximum one-sided connections
+    for directed graph and maximum total connections for undirected graph.
+    """
+    # Works with arc3 and angle3 connectionstyles
+    connectionstyle = [f"arc3,rad={r}" for r in it.accumulate([0.15] * 4)]
+    # connectionstyle = [f"angle3,angleA={r}" for r in it.accumulate([30] * 4)]
+
+    pos = nx.shell_layout(G)
+    nx.draw_networkx_nodes(G, pos, ax=ax)
+    nx.draw_networkx_labels(G, pos, font_size=20, ax=ax)
+    nx.draw_networkx_edges(
+        G, pos, edge_color="grey", connectionstyle=connectionstyle, ax=ax
+    )
+
+    labels = {
+        tuple(edge): f"{attr_name}={attrs[attr_name]}"
+        for *edge, attrs in G.edges(keys=True, data=True)
+    }
+    nx.draw_networkx_edge_labels(
+        G,
+        pos,
+        labels,
+        connectionstyle=connectionstyle,
+        label_pos=0.3,
+        font_color="blue",
+        bbox={"alpha": 0},
+        ax=ax,
+    )
+
+
+nodes = "ABC"
+prod = list(it.product(nodes, repeat=2))
+pair_dict = {f"Product x {i}": prod * i for i in range(1, 5)}
+
+
+fig, axes = plt.subplots(2, 2)
+for (name, pairs), ax in zip(pair_dict.items(), np.ravel(axes)):
+    G = nx.MultiDiGraph()
+    for i, (u, v) in enumerate(pairs):
+        G.add_edge(u, v, w=round(i / 3, 2))
+    draw_labeled_multigraph(G, "w", ax)
+    ax.set_title(name)
+fig.tight_layout()
+plt.show()
diff --git a/networkx/drawing/nx_pylab.py b/networkx/drawing/nx_pylab.py
index 096e7b01d05..727111fb7ce 100644
--- a/networkx/drawing/nx_pylab.py
+++ b/networkx/drawing/nx_pylab.py
@@ -16,6 +16,8 @@
  - :func:`matplotlib.pyplot.scatter`
  - :obj:`matplotlib.patches.FancyArrowPatch`
 """
+import collections
+import itertools
 from numbers import Number
 
 import networkx as nx
@@ -467,6 +469,197 @@ def draw_networkx_nodes(
     return node_collection
 
 
+class FancyArrowFactory:
+    """Draw arrows with `matplotlib.patches.FancyarrowPatch`"""
+
+    class ConnectionStyleFactory:
+        def __init__(self, connectionstyles, selfloop_height, ax=None):
+            import matplotlib as mpl
+            import matplotlib.path  # call as mpl.path
+            import numpy as np
+
+            self.ax = ax
+            self.mpl = mpl
+            self.np = np
+            self.base_connection_styles = [
+                mpl.patches.ConnectionStyle(cs) for cs in connectionstyles
+            ]
+            self.n = len(self.base_connection_styles)
+            self.selfloop_height = selfloop_height
+
+        def curved(self, edge_index):
+            return self.base_connection_styles[edge_index % self.n]
+
+        def self_loop(self, edge_index):
+            def self_loop_connection(posA, posB, *args, **kwargs):
+                if not self.np.all(posA == posB):
+                    raise nx.NetworkXError(
+                        "`self_loop` connection style method"
+                        "is only to be used for self-loops"
+                    )
+                # this is called with _screen space_ values
+                # so convert back to data space
+                data_loc = self.ax.transData.inverted().transform(posA)
+                v_shift = 0.1 * self.selfloop_height
+                h_shift = v_shift * 0.5
+                # put the top of the loop first so arrow is not hidden by node
+                path = self.np.asarray(
+                    [
+                        # 1
+                        [0, v_shift],
+                        # 4 4 4
+                        [h_shift, v_shift],
+                        [h_shift, 0],
+                        [0, 0],
+                        # 4 4 4
+                        [-h_shift, 0],
+                        [-h_shift, v_shift],
+                        [0, v_shift],
+                    ]
+                )
+                # Rotate self loop 90 deg. if more than 1
+                # This will allow for maximum of 4 visible self loops
+                if edge_index % 4:
+                    x, y = path.T
+                    for _ in range(edge_index % 4):
+                        x, y = y, -x
+                    path = self.np.array([x, y]).T
+                return self.mpl.path.Path(
+                    self.ax.transData.transform(data_loc + path), [1, 4, 4, 4, 4, 4, 4]
+                )
+
+            return self_loop_connection
+
+    def __init__(
+        self,
+        edge_pos,
+        edgelist,
+        nodelist,
+        edge_indices,
+        node_size,
+        selfloop_height,
+        connectionstyle="arc3",
+        node_shape="o",
+        arrowstyle="-",
+        arrowsize=10,
+        edge_color="k",
+        alpha=None,
+        linewidth=1.0,
+        style="solid",
+        min_source_margin=0,
+        min_target_margin=0,
+        ax=None,
+    ):
+        import matplotlib as mpl
+        import matplotlib.patches  # call as mpl.patches
+        import matplotlib.pyplot as plt
+        import numpy as np
+
+        if isinstance(connectionstyle, str):
+            connectionstyle = [connectionstyle]
+        elif np.iterable(connectionstyle):
+            connectionstyle = list(connectionstyle)
+        else:
+            msg = "ConnectionStyleFactory arg `connectionstyle` must be str or iterable"
+            raise nx.NetworkXError(msg)
+        self.ax = ax
+        self.mpl = mpl
+        self.np = np
+        self.edge_pos = edge_pos
+        self.edgelist = edgelist
+        self.nodelist = nodelist
+        self.node_shape = node_shape
+        self.min_source_margin = min_source_margin
+        self.min_target_margin = min_target_margin
+        self.edge_indices = edge_indices
+        self.node_size = node_size
+        self.connectionstyle_factory = self.ConnectionStyleFactory(
+            connectionstyle, selfloop_height, ax
+        )
+        self.arrowstyle = arrowstyle
+        self.arrowsize = arrowsize
+        self.arrow_colors = mpl.colors.colorConverter.to_rgba_array(edge_color, alpha)
+        self.linewidth = linewidth
+        self.style = style
+        if isinstance(arrowsize, list) and len(arrowsize) != len(edge_pos):
+            raise ValueError("arrowsize should have the same length as edgelist")
+
+    def __call__(self, i):
+        (x1, y1), (x2, y2) = self.edge_pos[i]
+        shrink_source = 0  # space from source to tail
+        shrink_target = 0  # space from  head to target
+        if self.np.iterable(self.node_size):  # many node sizes
+            source, target = self.edgelist[i][:2]
+            source_node_size = self.node_size[self.nodelist.index(source)]
+            target_node_size = self.node_size[self.nodelist.index(target)]
+            shrink_source = self.to_marker_edge(source_node_size, self.node_shape)
+            shrink_target = self.to_marker_edge(target_node_size, self.node_shape)
+        else:
+            shrink_source = self.to_marker_edge(self.node_size, self.node_shape)
+            shrink_target = shrink_source
+        shrink_source = max(shrink_source, self.min_source_margin)
+        shrink_target = max(shrink_target, self.min_target_margin)
+
+        # scale factor of arrow head
+        if isinstance(self.arrowsize, list):
+            mutation_scale = self.arrowsize[i]
+        else:
+            mutation_scale = self.arrowsize
+
+        if len(self.arrow_colors) > i:
+            arrow_color = self.arrow_colors[i]
+        elif len(self.arrow_colors) == 1:
+            arrow_color = self.arrow_colors[0]
+        else:  # Cycle through colors
+            arrow_color = self.arrow_colors[i % len(self.arrow_colors)]
+
+        if self.np.iterable(self.linewidth):
+            if len(self.linewidth) > i:
+                linewidth = self.linewidth[i]
+            else:
+                linewidth = self.linewidth[i % len(self.linewidth)]
+        else:
+            linewidth = self.linewidth
+
+        if (
+            self.np.iterable(self.style)
+            and not isinstance(self.style, str)
+            and not isinstance(self.style, tuple)
+        ):
+            if len(self.style) > i:
+                linestyle = self.style[i]
+            else:  # Cycle through styles
+                linestyle = self.style[i % len(self.style)]
+        else:
+            linestyle = self.style
+
+        if x1 == x2 and y1 == y2:
+            connectionstyle = self.connectionstyle_factory.self_loop(
+                self.edge_indices[i]
+            )
+        else:
+            connectionstyle = self.connectionstyle_factory.curved(self.edge_indices[i])
+        return self.mpl.patches.FancyArrowPatch(
+            (x1, y1),
+            (x2, y2),
+            arrowstyle=self.arrowstyle,
+            shrinkA=shrink_source,
+            shrinkB=shrink_target,
+            mutation_scale=mutation_scale,
+            color=arrow_color,
+            linewidth=linewidth,
+            connectionstyle=connectionstyle,
+            linestyle=linestyle,
+            zorder=1,  # arrows go behind nodes
+        )
+
+    def to_marker_edge(self, marker_size, marker):
+        if marker in "s^>v<d":  # `large` markers need extra space
+            return self.np.sqrt(2 * marker_size) / 2
+        else:
+            return self.np.sqrt(marker_size) / 2
+
+
 def draw_networkx_edges(
     G,
     pos,
@@ -561,11 +754,12 @@ def draw_networkx_edges(
         width. See `matplotlib.patches.FancyArrowPatch` for attribute
         `mutation_scale` for more info.
 
-    connectionstyle : string (default="arc3")
+    connectionstyle : string or iterable of strings (default="arc3")
         Pass the connectionstyle parameter to create curved arc of rounding
         radius rad. For example, connectionstyle='arc3,rad=0.2'.
         See `matplotlib.patches.ConnectionStyle` and
         `matplotlib.patches.FancyArrowPatch` for more info.
+        If Iterable, index indicates i'th edge key of MultiGraph
 
     node_size : scalar or array (default=300)
         Size of nodes. Though the nodes are not drawn with this function, the
@@ -645,11 +839,11 @@ def draw_networkx_edges(
     draw_networkx_edge_labels
 
     """
+    import warnings
+
     import matplotlib as mpl
     import matplotlib.collections  # call as mpl.collections
     import matplotlib.colors  # call as mpl.colors
-    import matplotlib.patches  # call as mpl.patches
-    import matplotlib.path  # call as mpl.path
     import matplotlib.pyplot as plt
     import numpy as np
 
@@ -657,56 +851,65 @@ def draw_networkx_edges(
     # undirected graphs (for performance reasons) and use FancyArrowPatches
     # for directed graphs.
     # The `arrows` keyword can be used to override the default behavior
-    use_linecollection = not G.is_directed()
-    if arrows in (True, False):
+    if arrows is None:
+        use_linecollection = not (G.is_directed() or G.is_multigraph())
+    else:
+        if not isinstance(arrows, bool):
+            raise TypeError("Argument `arrows` must be of type bool or None")
         use_linecollection = not arrows
 
+    if arrowstyle is None:
+        arrowstyle = "-|>" if G.is_directed() else "-"
+
+    if isinstance(connectionstyle, str):
+        connectionstyle = [connectionstyle]
+    elif np.iterable(connectionstyle):
+        connectionstyle = list(connectionstyle)
+    else:
+        msg = "draw_networkx_edges arg `connectionstyle` must be str or iterable"
+        raise nx.NetworkXError(msg)
+
     # Some kwargs only apply to FancyArrowPatches. Warn users when they use
     # non-default values for these kwargs when LineCollection is being used
     # instead of silently ignoring the specified option
-    if use_linecollection and any(
-        [
-            arrowstyle is not None,
-            arrowsize != 10,
-            connectionstyle != "arc3",
-            min_source_margin != 0,
-            min_target_margin != 0,
-        ]
-    ):
-        import warnings
-
+    if use_linecollection:
         msg = (
             "\n\nThe {0} keyword argument is not applicable when drawing edges\n"
             "with LineCollection.\n\n"
             "To make this warning go away, either specify `arrows=True` to\n"
-            "force FancyArrowPatches or use the default value for {0}.\n"
+            "force FancyArrowPatches or use the default values.\n"
             "Note that using FancyArrowPatches may be slow for large graphs.\n"
         )
         if arrowstyle is not None:
-            msg = msg.format("arrowstyle")
+            warnings.warn(msg.format("arrowstyle"), category=UserWarning, stacklevel=2)
         if arrowsize != 10:
-            msg = msg.format("arrowsize")
-        if connectionstyle != "arc3":
-            msg = msg.format("connectionstyle")
+            warnings.warn(msg.format("arrowsize"), category=UserWarning, stacklevel=2)
         if min_source_margin != 0:
-            msg = msg.format("min_source_margin")
+            warnings.warn(
+                msg.format("min_source_margin"), category=UserWarning, stacklevel=2
+            )
         if min_target_margin != 0:
-            msg = msg.format("min_target_margin")
-        warnings.warn(msg, category=UserWarning, stacklevel=2)
-
-    if arrowstyle == None:
-        if G.is_directed():
-            arrowstyle = "-|>"
-        else:
-            arrowstyle = "-"
+            warnings.warn(
+                msg.format("min_target_margin"), category=UserWarning, stacklevel=2
+            )
+        if any(cs != "arc3" for cs in connectionstyle):
+            warnings.warn(
+                msg.format("connectionstyle"), category=UserWarning, stacklevel=2
+            )
 
     if ax is None:
         ax = plt.gca()
 
     if edgelist is None:
-        edgelist = list(G.edges())
+        edgelist = list(G.edges)  # (u, v, k) for multigraph (u, v) otherwise
 
-    if len(edgelist) == 0:  # no edges!
+    if len(edgelist):
+        if G.is_multigraph():
+            key_count = collections.defaultdict(lambda: itertools.count(0))
+            edge_indices = [next(key_count[tuple(e[:2])]) for e in edgelist]
+        else:
+            edge_indices = [0] * len(edgelist)
+    else:  # no edges!
         return []
 
     if nodelist is None:
@@ -715,7 +918,6 @@ def draw_networkx_edges(
     # FancyArrowPatch handles color=None different from LineCollection
     if edge_color is None:
         edge_color = "k"
-    edgelist_tuple = list(map(tuple, edgelist))
 
     # set edge positions
     edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in edgelist])
@@ -738,7 +940,40 @@ def draw_networkx_edges(
         color_normal = mpl.colors.Normalize(vmin=edge_vmin, vmax=edge_vmax)
         edge_color = [edge_cmap(color_normal(e)) for e in edge_color]
 
-    def _draw_networkx_edges_line_collection():
+    # compute initial view
+    minx = np.amin(np.ravel(edge_pos[:, :, 0]))
+    maxx = np.amax(np.ravel(edge_pos[:, :, 0]))
+    miny = np.amin(np.ravel(edge_pos[:, :, 1]))
+    maxy = np.amax(np.ravel(edge_pos[:, :, 1]))
+    w = maxx - minx
+    h = maxy - miny
+
+    # Self-loops are scaled by view extent, except in cases the extent
+    # is 0, e.g. for a single node. In this case, fall back to scaling
+    # by the maximum node size
+    selfloop_height = h if h != 0 else 0.005 * np.array(node_size).max()
+    fancy_arrow_factory = FancyArrowFactory(
+        edge_pos,
+        edgelist,
+        nodelist,
+        edge_indices,
+        node_size,
+        selfloop_height,
+        connectionstyle,
+        node_shape,
+        arrowstyle,
+        arrowsize,
+        edge_color,
+        alpha,
+        width,
+        style,
+        min_source_margin,
+        min_target_margin,
+        ax=ax,
+    )
+
+    # Draw the edges
+    if use_linecollection:
         edge_collection = mpl.collections.LineCollection(
             edge_pos,
             colors=edge_color,
@@ -752,171 +987,31 @@ def _draw_networkx_edges_line_collection():
         edge_collection.set_zorder(1)  # edges go behind nodes
         edge_collection.set_label(label)
         ax.add_collection(edge_collection)
+        edge_viz_obj = edge_collection
 
-        return edge_collection
-
-    def _draw_networkx_edges_fancy_arrow_patch():
-        # Note: Waiting for someone to implement arrow to intersection with
-        # marker.  Meanwhile, this works well for polygons with more than 4
-        # sides and circle.
-
-        def to_marker_edge(marker_size, marker):
-            if marker in "s^>v<d":  # `large` markers need extra space
-                return np.sqrt(2 * marker_size) / 2
-            else:
-                return np.sqrt(marker_size) / 2
-
-        # Draw arrows with `matplotlib.patches.FancyarrowPatch`
-        arrow_collection = []
-
-        if isinstance(arrowsize, list):
-            if len(arrowsize) != len(edge_pos):
-                raise ValueError("arrowsize should have the same length as edgelist")
-        else:
-            mutation_scale = arrowsize  # scale factor of arrow head
-
-        base_connection_style = mpl.patches.ConnectionStyle(connectionstyle)
-
-        # Fallback for self-loop scale. Left outside of _connectionstyle so it is
-        # only computed once
-        max_nodesize = np.array(node_size).max()
-
-        def _connectionstyle(posA, posB, *args, **kwargs):
-            # check if we need to do a self-loop
-            if np.all(posA == posB):
-                # Self-loops are scaled by view extent, except in cases the extent
-                # is 0, e.g. for a single node. In this case, fall back to scaling
-                # by the maximum node size
-                selfloop_ht = 0.005 * max_nodesize if h == 0 else h
-                # this is called with _screen space_ values so convert back
-                # to data space
-                data_loc = ax.transData.inverted().transform(posA)
-                v_shift = 0.1 * selfloop_ht
-                h_shift = v_shift * 0.5
-                # put the top of the loop first so arrow is not hidden by node
-                path = [
-                    # 1
-                    data_loc + np.asarray([0, v_shift]),
-                    # 4 4 4
-                    data_loc + np.asarray([h_shift, v_shift]),
-                    data_loc + np.asarray([h_shift, 0]),
-                    data_loc,
-                    # 4 4 4
-                    data_loc + np.asarray([-h_shift, 0]),
-                    data_loc + np.asarray([-h_shift, v_shift]),
-                    data_loc + np.asarray([0, v_shift]),
-                ]
-
-                ret = mpl.path.Path(ax.transData.transform(path), [1, 4, 4, 4, 4, 4, 4])
-            # if not, fall back to the user specified behavior
-            else:
-                ret = base_connection_style(posA, posB, *args, **kwargs)
-
-            return ret
-
-        # FancyArrowPatch doesn't handle color strings
-        arrow_colors = mpl.colors.colorConverter.to_rgba_array(edge_color, alpha)
-        for i, (src, dst) in zip(fancy_edges_indices, edge_pos):
-            x1, y1 = src
-            x2, y2 = dst
-            shrink_source = 0  # space from source to tail
-            shrink_target = 0  # space from  head to target
-
-            if isinstance(arrowsize, list):
-                # Scale each factor of each arrow based on arrowsize list
-                mutation_scale = arrowsize[i]
-
-            if np.iterable(node_size):  # many node sizes
-                source, target = edgelist[i][:2]
-                source_node_size = node_size[nodelist.index(source)]
-                target_node_size = node_size[nodelist.index(target)]
-                shrink_source = to_marker_edge(source_node_size, node_shape)
-                shrink_target = to_marker_edge(target_node_size, node_shape)
-            else:
-                shrink_source = shrink_target = to_marker_edge(node_size, node_shape)
-
-            if shrink_source < min_source_margin:
-                shrink_source = min_source_margin
-
-            if shrink_target < min_target_margin:
-                shrink_target = min_target_margin
-
-            if len(arrow_colors) > i:
-                arrow_color = arrow_colors[i]
-            elif len(arrow_colors) == 1:
-                arrow_color = arrow_colors[0]
-            else:  # Cycle through colors
-                arrow_color = arrow_colors[i % len(arrow_colors)]
-
-            if np.iterable(width):
-                if len(width) > i:
-                    line_width = width[i]
-                else:
-                    line_width = width[i % len(width)]
-            else:
-                line_width = width
-
-            if (
-                np.iterable(style)
-                and not isinstance(style, str)
-                and not isinstance(style, tuple)
-            ):
-                if len(style) > i:
-                    linestyle = style[i]
-                else:  # Cycle through styles
-                    linestyle = style[i % len(style)]
-            else:
-                linestyle = style
-
-            arrow = mpl.patches.FancyArrowPatch(
-                (x1, y1),
-                (x2, y2),
-                arrowstyle=arrowstyle,
-                shrinkA=shrink_source,
-                shrinkB=shrink_target,
-                mutation_scale=mutation_scale,
-                color=arrow_color,
-                linewidth=line_width,
-                connectionstyle=_connectionstyle,
-                linestyle=linestyle,
-                zorder=1,
-            )  # arrows go behind nodes
-
-            arrow_collection.append(arrow)
-            ax.add_patch(arrow)
-
-        return arrow_collection
-
-    # compute initial view
-    minx = np.amin(np.ravel(edge_pos[:, :, 0]))
-    maxx = np.amax(np.ravel(edge_pos[:, :, 0]))
-    miny = np.amin(np.ravel(edge_pos[:, :, 1]))
-    maxy = np.amax(np.ravel(edge_pos[:, :, 1]))
-    w = maxx - minx
-    h = maxy - miny
-
-    # Draw the edges
-    if use_linecollection:
-        edge_viz_obj = _draw_networkx_edges_line_collection()
         # Make sure selfloop edges are also drawn
+        # ---------------------------------------
         selfloops_to_draw = [loop for loop in nx.selfloop_edges(G) if loop in edgelist]
         if selfloops_to_draw:
-            fancy_edges_indices = [
-                edgelist_tuple.index(loop) for loop in selfloops_to_draw
-            ]
-            edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in selfloops_to_draw])
-            arrowstyle = "-"
-            _draw_networkx_edges_fancy_arrow_patch()
+            edgelist_tuple = list(map(tuple, edgelist))
+            arrow_collection = []
+            for loop in selfloops_to_draw:
+                i = edgelist_tuple.index(loop)
+                arrow = fancy_arrow_factory(i)
+                arrow_collection.append(arrow)
+                ax.add_patch(arrow)
     else:
-        fancy_edges_indices = range(len(edgelist))
-        edge_viz_obj = _draw_networkx_edges_fancy_arrow_patch()
+        edge_viz_obj = []
+        for i in range(len(edgelist)):
+            arrow = fancy_arrow_factory(i)
+            ax.add_patch(arrow)
+            edge_viz_obj.append(arrow)
 
     # update view after drawing
     padx, pady = 0.05 * w, 0.05 * h
     corners = (minx - padx, miny - pady), (maxx + padx, maxy + pady)
     ax.update_datalim(corners)
     ax.autoscale_view()
-
     ax.tick_params(
         axis="both",
         which="both",
@@ -1070,6 +1165,9 @@ def draw_networkx_edge_labels(
     ax=None,
     rotate=True,
     clip_on=True,
+    node_size=300,
+    nodelist=None,
+    connectionstyle="arc3",
 ):
     """Draw edge labels.
 
@@ -1124,6 +1222,19 @@ def draw_networkx_edge_labels(
     clip_on : bool (default=True)
         Turn on clipping of edge labels at axis boundaries
 
+    node_size : scalar or array (default=300)
+        Size of nodes.  If an array it must be the same length as nodelist.
+
+    nodelist : list, optional (default=G.nodes())
+       This provides the node order for the `node_size` array (if it is an array).
+
+    connectionstyle : string or iterable of strings (default="arc3")
+        Pass the connectionstyle parameter to create curved arc of rounding
+        radius rad. For example, connectionstyle='arc3,rad=0.2'.
+        See `matplotlib.patches.ConnectionStyle` and
+        `matplotlib.patches.FancyArrowPatch` for more info.
+        If Iterable, index indicates i'th edge key of MultiGraph
+
     Returns
     -------
     dict
@@ -1145,73 +1256,204 @@ def draw_networkx_edge_labels(
     draw_networkx_edges
     draw_networkx_labels
     """
+    import matplotlib as mpl
     import matplotlib.pyplot as plt
     import numpy as np
 
+    class CurvedArrowText(mpl.text.Text):
+        def __init__(
+            self,
+            arrow,
+            *args,
+            label_pos=0.5,
+            labels_horizontal=False,
+            ax=None,
+            **kwargs,
+        ):
+            # Bind to FancyArrowPatch
+            self.arrow = arrow
+            # how far along the text should be on the curve,
+            # 0 is at start, 1 is at end etc.
+            self.label_pos = label_pos
+            self.labels_horizontal = labels_horizontal
+            if ax is None:
+                ax = plt.gca()
+            self.ax = ax
+            self.x, self.y, self.angle = self._update_text_pos_angle(arrow)
+
+            # Create text object
+            super().__init__(self.x, self.y, *args, rotation=self.angle, **kwargs)
+            # Bind to axis
+            self.ax.add_artist(self)
+
+        def _get_arrow_path_disp(self, arrow):
+            """
+            This is part of FancyArrowPatch._get_path_in_displaycoord
+            It omits the second part of the method where path is converted
+                to polygon based on width
+            The transform is taken from ax, not the object, as the object
+                has not been added yet, and doesn't have transform
+            """
+            dpi_cor = arrow._dpi_cor
+            # trans_data = arrow.get_transform()
+            trans_data = self.ax.transData
+            if arrow._posA_posB is not None:
+                posA = arrow._convert_xy_units(arrow._posA_posB[0])
+                posB = arrow._convert_xy_units(arrow._posA_posB[1])
+                (posA, posB) = trans_data.transform((posA, posB))
+                _path = arrow.get_connectionstyle()(
+                    posA,
+                    posB,
+                    patchA=arrow.patchA,
+                    patchB=arrow.patchB,
+                    shrinkA=arrow.shrinkA * dpi_cor,
+                    shrinkB=arrow.shrinkB * dpi_cor,
+                )
+            else:
+                _path = trans_data.transform_path(arrow._path_original)
+            # Return is in display coordinates
+            return _path
+
+        def _update_text_pos_angle(self, arrow):
+            # Fractional label position
+            path_disp = self._get_arrow_path_disp(arrow)
+            (x1, y1), (cx, cy), (x2, y2) = path_disp.vertices
+            # Text position at a proportion t along the line in display coords
+            # default is 0.5 so text appears at the halfway point
+            t = self.label_pos
+            tt = 1 - t
+            x = tt**2 * x1 + 2 * t * tt * cx + t**2 * x2
+            y = tt**2 * y1 + 2 * t * tt * cy + t**2 * y2
+            if self.labels_horizontal:
+                # Horizontal text labels
+                angle = 0
+            else:
+                # Labels parallel to curve
+                change_x = 2 * tt * (cx - x1) + 2 * t * (x2 - cx)
+                change_y = 2 * tt * (cy - y1) + 2 * t * (y2 - cy)
+                angle = (np.arctan2(change_y, change_x) / (2 * np.pi)) * 360
+                # Text is "right way up"
+                if angle > 90:
+                    angle -= 180
+                if angle < -90:
+                    angle += 180
+            (x, y) = self.ax.transData.inverted().transform((x, y))
+            return x, y, angle
+
+        def draw(self, renderer):
+            # recalculate the text position and angle
+            self.x, self.y, self.angle = self._update_text_pos_angle(self.arrow)
+            self.set_position((self.x, self.y))
+            self.set_rotation(self.angle)
+            # redraw text
+            super().draw(renderer)
+
+    # use default box of white with white border
+    if bbox is None:
+        bbox = {"boxstyle": "round", "ec": (1.0, 1.0, 1.0), "fc": (1.0, 1.0, 1.0)}
+
+    if isinstance(connectionstyle, str):
+        connectionstyle = [connectionstyle]
+    elif np.iterable(connectionstyle):
+        connectionstyle = list(connectionstyle)
+    else:
+        raise nx.NetworkXError(
+            "draw_networkx_edges arg `connectionstyle` must be"
+            "string or iterable of strings"
+        )
+
     if ax is None:
         ax = plt.gca()
+
     if edge_labels is None:
-        labels = {(u, v): d for u, v, d in G.edges(data=True)}
+        kwds = {"keys": True} if G.is_multigraph() else {}
+        edge_labels = {tuple(edge): d for *edge, d in G.edges(data=True, **kwds)}
+    # NOTHING TO PLOT
+    if not edge_labels:
+        return {}
+    edgelist, labels = zip(*edge_labels.items())
+
+    if nodelist is None:
+        nodelist = list(G.nodes())
+
+    # set edge positions
+    edge_pos = np.asarray([(pos[e[0]], pos[e[1]]) for e in edgelist])
+
+    if G.is_multigraph():
+        key_count = collections.defaultdict(lambda: itertools.count(0))
+        edge_indices = [next(key_count[tuple(e[:2])]) for e in edgelist]
     else:
-        labels = edge_labels
-        # Informative exception for multiedges
-        try:
-            (u, v) = next(iter(labels))  # ensures no edge key provided
-        except ValueError as err:
-            raise nx.NetworkXError(
-                "draw_networkx_edge_labels does not support multiedges."
-            ) from err
-        except StopIteration:
-            pass
+        edge_indices = [0] * len(edgelist)
+
+    # Used to determine self loop mid-point
+    # Note, that this will not be accurate,
+    #   if not drawing edge_labels for all edges drawn
+    h = 0
+    if edge_labels:
+        miny = np.amin(np.ravel(edge_pos[:, :, 1]))
+        maxy = np.amax(np.ravel(edge_pos[:, :, 1]))
+        h = maxy - miny
+    selfloop_height = h if h != 0 else 0.005 * np.array(node_size).max()
+    fancy_arrow_factory = FancyArrowFactory(
+        edge_pos,
+        edgelist,
+        nodelist,
+        edge_indices,
+        node_size,
+        selfloop_height,
+        connectionstyle,
+        ax=ax,
+    )
 
     text_items = {}
-    for (n1, n2), label in labels.items():
-        (x1, y1) = pos[n1]
-        (x2, y2) = pos[n2]
-        (x, y) = (
-            x1 * label_pos + x2 * (1.0 - label_pos),
-            y1 * label_pos + y2 * (1.0 - label_pos),
-        )
-
-        if rotate:
-            # in degrees
-            angle = np.arctan2(y2 - y1, x2 - x1) / (2.0 * np.pi) * 360
-            # make label orientation "right-side-up"
-            if angle > 90:
-                angle -= 180
-            if angle < -90:
-                angle += 180
-            # transform data coordinate angle to screen coordinate angle
-            xy = np.array((x, y))
-            trans_angle = ax.transData.transform_angles(
-                np.array((angle,)), xy.reshape((1, 2))
-            )[0]
-        else:
-            trans_angle = 0.0
-        # use default box of white with white border
-        if bbox is None:
-            bbox = {"boxstyle": "round", "ec": (1.0, 1.0, 1.0), "fc": (1.0, 1.0, 1.0)}
+    for i, (edge, label) in enumerate(zip(edgelist, labels)):
         if not isinstance(label, str):
             label = str(label)  # this makes "1" and 1 labeled the same
 
-        t = ax.text(
-            x,
-            y,
-            label,
-            size=font_size,
-            color=font_color,
-            family=font_family,
-            weight=font_weight,
-            alpha=alpha,
-            horizontalalignment=horizontalalignment,
-            verticalalignment=verticalalignment,
-            rotation=trans_angle,
-            transform=ax.transData,
-            bbox=bbox,
-            zorder=1,
-            clip_on=clip_on,
-        )
-        text_items[(n1, n2)] = t
+        n1, n2 = edge[:2]
+        arrow = fancy_arrow_factory(i)
+        if n1 == n2:
+            connectionstyle_obj = arrow.get_connectionstyle()
+            posA = ax.transData.transform(pos[n1])
+            path_disp = connectionstyle_obj(posA, posA)
+            path_data = ax.transData.inverted().transform_path(path_disp)
+            x, y = path_data.vertices[0]
+            text_items[edge] = ax.text(
+                x,
+                y,
+                label,
+                size=font_size,
+                color=font_color,
+                family=font_family,
+                weight=font_weight,
+                alpha=alpha,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                rotation=0,
+                transform=ax.transData,
+                bbox=bbox,
+                zorder=1,
+                clip_on=clip_on,
+            )
+        else:
+            text_items[edge] = CurvedArrowText(
+                arrow,
+                label,
+                size=font_size,
+                color=font_color,
+                family=font_family,
+                weight=font_weight,
+                alpha=alpha,
+                horizontalalignment=horizontalalignment,
+                verticalalignment=verticalalignment,
+                transform=ax.transData,
+                bbox=bbox,
+                zorder=1,
+                clip_on=clip_on,
+                label_pos=label_pos,
+                labels_horizontal=not rotate,
+                ax=ax,
+            )
 
     ax.tick_params(
         axis="both",
diff --git a/networkx/drawing/tests/test_pylab.py b/networkx/drawing/tests/test_pylab.py
index 668a627077d..bfc22627347 100644
--- a/networkx/drawing/tests/test_pylab.py
+++ b/networkx/drawing/tests/test_pylab.py
@@ -706,19 +706,63 @@ def test_edgelist_kwarg_not_ignored():
     plt.delaxes(ax)
 
 
-def test_draw_networkx_edge_label_multiedge_exception():
-    """
-    draw_networkx_edge_labels should raise an informative error message when
-    the edge label includes keys
-    """
-    exception_msg = "draw_networkx_edge_labels does not support multiedges"
+@pytest.mark.parametrize(
+    ("G", "expected_n_edges"),
+    ([nx.DiGraph(), 2], [nx.MultiGraph(), 4], [nx.MultiDiGraph(), 4]),
+)
+def test_draw_networkx_edges_multiedge_connectionstyle(G, expected_n_edges):
+    """Draws edges correctly for 3 types of graphs and checks for valid length"""
+    for i, (u, v) in enumerate([(0, 1), (0, 1), (0, 1), (0, 2)]):
+        G.add_edge(u, v, weight=round(i / 3, 2))
+    pos = {n: (n, n) for n in G}
+    # Raises on insuficient connectionstyle length
+    for conn_style in [
+        "arc3,rad=0.1",
+        ["arc3,rad=0.1", "arc3,rad=0.1"],
+        ["arc3,rad=0.1", "arc3,rad=0.1", "arc3,rad=0.2"],
+    ]:
+        nx.draw_networkx_edges(G, pos, connectionstyle=conn_style)
+        arrows = nx.draw_networkx_edges(G, pos, connectionstyle=conn_style)
+        assert len(arrows) == expected_n_edges
+
+
+@pytest.mark.parametrize(
+    ("G", "expected_n_edges"),
+    ([nx.DiGraph(), 2], [nx.MultiGraph(), 4], [nx.MultiDiGraph(), 4]),
+)
+def test_draw_networkx_edge_labels_multiedge_connectionstyle(G, expected_n_edges):
+    """Draws labels correctly for 3 types of graphs and checks for valid length and class names"""
+    for i, (u, v) in enumerate([(0, 1), (0, 1), (0, 1), (0, 2)]):
+        G.add_edge(u, v, weight=round(i / 3, 2))
+    pos = {n: (n, n) for n in G}
+    # Raises on insuficient connectionstyle length
+    arrows = nx.draw_networkx_edges(
+        G, pos, connectionstyle=["arc3,rad=0.1", "arc3,rad=0.1", "arc3,rad=0.1"]
+    )
+    for conn_style in [
+        "arc3,rad=0.1",
+        ["arc3,rad=0.1", "arc3,rad=0.2"],
+        ["arc3,rad=0.1", "arc3,rad=0.1", "arc3,rad=0.1"],
+    ]:
+        text_items = nx.draw_networkx_edge_labels(G, pos, connectionstyle=conn_style)
+        assert len(text_items) == expected_n_edges
+        for ti in text_items.values():
+            assert ti.__class__.__name__ == "CurvedArrowText"
+
+
+def test_draw_networkx_edge_label_multiedge():
     G = nx.MultiGraph()
     G.add_edge(0, 1, weight=10)
     G.add_edge(0, 1, weight=20)
     edge_labels = nx.get_edge_attributes(G, "weight")  # Includes edge keys
     pos = {n: (n, n) for n in G}
-    with pytest.raises(nx.NetworkXError, match=exception_msg):
-        nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+    text_items = nx.draw_networkx_edge_labels(
+        G,
+        pos,
+        edge_labels=edge_labels,
+        connectionstyle=["arc3,rad=0.1", "arc3,rad=0.2"],
+    )
+    assert len(text_items) == 2
 
 
 def test_draw_networkx_edge_label_empty_dict():

From 923e0295e8f2b922e234dae4568e7e30d6417338 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Tue, 6 Feb 2024 11:38:52 -0800
Subject: [PATCH 062/129] Add minimum_cycle_basis to cycle_basis See Also.
 (#7274)

---
 networkx/algorithms/cycles.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/networkx/algorithms/cycles.py b/networkx/algorithms/cycles.py
index dd7d4513a71..576c8b81f41 100644
--- a/networkx/algorithms/cycles.py
+++ b/networkx/algorithms/cycles.py
@@ -66,6 +66,7 @@ def cycle_basis(G, root=None):
     See Also
     --------
     simple_cycles
+    minimum_cycle_basis
     """
     gnodes = dict.fromkeys(G)  # set-like object that maintains node order
     cycles = []

From 31ef96361fc95ce8789d780cbc5bb4b3c4e27eb9 Mon Sep 17 00:00:00 2001
From: Vanshika Mishra <74042272+vanshika230@users.noreply.github.com>
Date: Wed, 7 Feb 2024 01:10:39 +0530
Subject: [PATCH 063/129] Improving test coverage for Mycielsky.py  (#7271)

* Improving Mycielski_TestCov

* fix ruff error
---
 networkx/generators/tests/test_mycielski.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/networkx/generators/tests/test_mycielski.py b/networkx/generators/tests/test_mycielski.py
index d71260edc34..eb12b1412ad 100644
--- a/networkx/generators/tests/test_mycielski.py
+++ b/networkx/generators/tests/test_mycielski.py
@@ -1,5 +1,7 @@
 """Unit tests for the :mod:`networkx.generators.mycielski` module."""
 
+import pytest
+
 import networkx as nx
 
 
@@ -24,3 +26,5 @@ def test_mycielski_graph_generator(self):
         assert nx.is_isomorphic(G, nx.cycle_graph(5))
         G = nx.mycielski_graph(4)
         assert nx.is_isomorphic(G, nx.mycielskian(nx.cycle_graph(5)))
+        with pytest.raises(nx.NetworkXError, match="must satisfy n >= 1"):
+            nx.mycielski_graph(0)

From 313508e927131c3b8ccdc717aced8048cb1e6c2b Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Thu, 8 Feb 2024 01:13:29 +0530
Subject: [PATCH 064/129] Use github actions to run a comparison benchmark
 (#7268)

---
 .github/workflows/benchmark.yml | 117 ++++++++++++++++++++++++++++++++
 1 file changed, 117 insertions(+)
 create mode 100644 .github/workflows/benchmark.yml

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
new file mode 100644
index 00000000000..4614bc8141c
--- /dev/null
+++ b/.github/workflows/benchmark.yml
@@ -0,0 +1,117 @@
+### Inspired from https://github.com/scikit-image/scikit-image/blob/main/.github/workflows/benchmarks.yml
+
+name: Benchmark PR
+on:
+  pull_request:
+    types: [labeled, synchronize]
+
+jobs:
+  ## This code below is to make sure a new commit on a PR with the label
+  ## retriggers the benchmark, otherwise the label needs to be removed and
+  ## applied again to run the benchmark.
+  check:
+    runs-on: ubuntu-latest
+    outputs:
+      result: ${{ steps.check.outputs.result }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/github-script@v7
+        name: Check for benchmark label and new commit
+        id: check
+        with:
+          script: |
+            const { owner, repo, number: pull_number } = context.issue;
+
+            // Check for label
+            const { data: pullRequest } = await github.rest.pulls.get({ owner, repo, pull_number });
+            if (!pullRequest.labels.some(({ name }) => name === 'run:benchmark')) {
+              return false;
+            }
+
+            // Check for repo name and organization name
+            const { data: repository } = await github.rest.repos.get({ owner, repo });
+            return repository.name === 'networkx' && repository.owner.login === 'networkx';
+  benchmark:
+    needs: check
+    if: ${{ needs.check.outputs.result == 'true' }}
+    # if: contains(github.event.pull_request.labels.*.name, 'run:benchmark') || ${{ github.event.label.name == 'run:benchmark' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+
+      - name: Setup some dependencies
+        shell: bash -l {0}
+        run: |
+          sudo apt-get update -y && sudo apt-get install -y ccache
+          # Make gcc/gxx symlinks first in path
+          sudo /usr/sbin/update-ccache-symlinks
+          echo "/usr/lib/ccache" >> $GITHUB_PATH
+
+      - name: "Prepare ccache"
+        id: prepare-ccache
+        shell: bash -l {0}
+        run: |
+          echo "key=benchmark-$RUNNER_OS" >> $GITHUB_OUTPUT
+          echo "timestamp=$(date +%Y%m%d-%H%M%S)" >> $GITHUB_OUTPUT
+          ccache -p
+          ccache -z
+
+      - name: "Restore ccache"
+        uses: actions/cache@v3
+        with:
+          path: .ccache
+          key: ccache-${{ secrets.CACHE_VERSION }}-${{ steps.prepare-ccache.outputs.key }}-${{ steps.prepare-ccache.outputs.timestamp }}
+          restore-keys: |
+            ccache-${{ secrets.CACHE_VERSION }}-${{ steps.prepare-ccache.outputs.key }}-
+
+      - name: Install packages
+        run: |
+          pip install --upgrade pip
+          pip install -r requirements/default.txt
+          pip install .
+          pip list
+
+      - name: Run benchmarks
+        shell: bash -l {0}
+        id: benchmark
+        env:
+          ASV_FACTOR: 1.5
+          ASV_SKIP_SLOW: 1
+        run: |
+          set -x
+          python -m pip install asv virtualenv packaging
+          cd benchmarks/
+
+          # ID this runner
+          python -m asv machine --yes --conf asv.conf.json
+
+          echo "Baseline:  ${{ github.event.pull_request.base.sha }} (${{ github.event.pull_request.base.label }})"
+
+          echo "Contender: ${GITHUB_SHA} (${{ github.event.pull_request.head.label }})"
+
+          # Run benchmarks for current commit against base
+          ASV_OPTIONS="--split --show-stderr --factor $ASV_FACTOR --conf asv.conf.json"
+          python -m asv continuous $ASV_OPTIONS ${{ github.event.pull_request.base.sha }} ${GITHUB_SHA} \
+              | sed "/Traceback \|failed$\|PERFORMANCE DECREASED/ s/^/::error::/" \
+              | tee benchmarks.log
+
+          # Report and export results for subsequent steps
+          if grep "Traceback \|failed\|PERFORMANCE DECREASED" benchmarks.log > /dev/null ; then
+             exit 1
+          fi
+
+      - name: "Check ccache performance"
+        shell: bash -l {0}
+        run: ccache -s
+        if: always()
+
+      - uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: asv-benchmark-results-${{ runner.os }}
+          path: benchmarks.log

From 64489da5385d7b3cdfa3dc9b0d12cfcc21a1468f Mon Sep 17 00:00:00 2001
From: Chris Pryer <14341145+cnpryer@users.noreply.github.com>
Date: Thu, 8 Feb 2024 23:54:30 -0500
Subject: [PATCH 065/129] DOC: Replace mention of black with pre-commit in
 contributing guide (#7270)

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 CONTRIBUTING.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index 7acff214fa6..623af3ee730 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -78,8 +78,8 @@ Development Workflow
          # Test your installation
          pytest --pyargs networkx
 
-   * Finally, we recommend you use a pre-commit hook, which runs black when
-     you type ``git commit``::
+   * Finally, we recommend you install pre-commit which checks
+     that your code matches formatting guidelines::
 
        pre-commit install
 

From 3c0f096f66ab352cfaf8dbe2d5fc5731cbbc4338 Mon Sep 17 00:00:00 2001
From: Chris Pryer <14341145+cnpryer@users.noreply.github.com>
Date: Fri, 9 Feb 2024 13:13:31 -0500
Subject: [PATCH 066/129] Update docstring formatter (#7276)

Switch from blacken-docs to ruff-format for docstrings.
---
 .pre-commit-config.yaml                       |  4 --
 .../approximation/traveling_salesman.py       | 69 ++++++++++++++-----
 networkx/algorithms/assortativity/mixing.py   | 12 ++--
 networkx/algorithms/bipartite/projection.py   | 13 +---
 networkx/algorithms/clique.py                 |  3 +-
 .../components/strongly_connected.py          | 11 ++-
 .../algorithms/components/weakly_connected.py |  5 +-
 .../algorithms/connectivity/connectivity.py   |  2 -
 networkx/algorithms/dag.py                    |  8 +--
 networkx/algorithms/flow/maxflow.py           | 12 +---
 networkx/algorithms/graph_hashing.py          |  8 +--
 .../algorithms/isomorphism/matchhelpers.py    |  1 -
 .../isomorphism/temporalisomorphvf2.py        |  8 +--
 networkx/algorithms/minors/contraction.py     |  9 ++-
 networkx/algorithms/non_randomness.py         |  2 +-
 networkx/algorithms/operators/all.py          |  7 +-
 networkx/algorithms/operators/binary.py       | 28 ++++----
 networkx/algorithms/operators/unary.py        |  2 +-
 networkx/algorithms/shortest_paths/dense.py   |  2 +-
 networkx/algorithms/shortest_paths/generic.py |  6 +-
 .../algorithms/shortest_paths/weighted.py     |  5 +-
 networkx/algorithms/similarity.py             | 10 +--
 networkx/algorithms/simple_paths.py           |  2 +-
 networkx/algorithms/summarization.py          | 10 +--
 networkx/algorithms/threshold.py              |  2 +-
 networkx/algorithms/time_dependent.py         |  4 +-
 .../traversal/breadth_first_search.py         |  2 +-
 networkx/algorithms/triads.py                 |  5 +-
 networkx/classes/digraph.py                   |  2 +-
 networkx/classes/graph.py                     | 34 ++++-----
 networkx/classes/graphviews.py                |  8 ++-
 networkx/classes/multidigraph.py              | 14 ++--
 networkx/classes/multigraph.py                |  2 +-
 networkx/classes/reportviews.py               | 24 ++++---
 networkx/convert.py                           | 18 +++--
 networkx/convert_matrix.py                    | 12 ++--
 networkx/drawing/nx_pydot.py                  |  6 +-
 networkx/generators/classic.py                |  2 -
 networkx/generators/community.py              |  2 -
 networkx/generators/directed.py               |  2 +-
 networkx/generators/geometric.py              | 12 ++--
 networkx/generators/line.py                   |  2 +-
 networkx/generators/triads.py                 | 20 +++++-
 networkx/lazy_imports.py                      |  8 +--
 networkx/linalg/laplacianmatrix.py            | 18 ++++-
 networkx/readwrite/json_graph/cytoscape.py    | 16 +++--
 networkx/readwrite/json_graph/node_link.py    |  2 +-
 networkx/readwrite/text.py                    | 20 +++---
 networkx/relabel.py                           |  2 +-
 networkx/utils/decorators.py                  | 51 +++++++++-----
 networkx/utils/mapped_queue.py                | 12 ++--
 networkx/utils/misc.py                        |  2 +-
 pyproject.toml                                |  3 +
 53 files changed, 303 insertions(+), 243 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 719aedfbbb0..a0423daf37a 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -2,10 +2,6 @@
 # pre-commit install
 
 repos:
-  - repo: https://github.com/adamchainz/blacken-docs
-    rev: 1.16.0
-    hooks:
-      - id: blacken-docs
   - repo: https://github.com/pre-commit/mirrors-prettier
     rev: v3.1.0
     hooks:
diff --git a/networkx/algorithms/approximation/traveling_salesman.py b/networkx/algorithms/approximation/traveling_salesman.py
index 111ed7d60c7..f2127e3066c 100644
--- a/networkx/algorithms/approximation/traveling_salesman.py
+++ b/networkx/algorithms/approximation/traveling_salesman.py
@@ -407,8 +407,10 @@ def asadpour_atsp(G, weight="weight", seed=None, source=None):
     >>> import networkx as nx
     >>> import networkx.algorithms.approximation as approx
     >>> G = nx.complete_graph(3, create_using=nx.DiGraph)
-    >>> nx.set_edge_attributes(G, {(0, 1): 2, (1, 2): 2, (2, 0): 2, (0, 2): 1, (2, 1): 1, (1, 0): 1}, "weight")
-    >>> tour = approx.asadpour_atsp(G,source=0)
+    >>> nx.set_edge_attributes(
+    ...     G, {(0, 1): 2, (1, 2): 2, (2, 0): 2, (0, 2): 1, (2, 1): 1, (1, 0): 1}, "weight"
+    ... )
+    >>> tour = approx.asadpour_atsp(G, source=0)
     >>> tour
     [0, 2, 1, 0]
     """
@@ -951,11 +953,22 @@ def greedy_tsp(G, weight="weight", source=None):
     --------
     >>> from networkx.algorithms import approximation as approx
     >>> G = nx.DiGraph()
-    >>> G.add_weighted_edges_from({
-    ...     ("A", "B", 3), ("A", "C", 17), ("A", "D", 14), ("B", "A", 3),
-    ...     ("B", "C", 12), ("B", "D", 16), ("C", "A", 13),("C", "B", 12),
-    ...     ("C", "D", 4), ("D", "A", 14), ("D", "B", 15), ("D", "C", 2)
-    ... })
+    >>> G.add_weighted_edges_from(
+    ...     {
+    ...         ("A", "B", 3),
+    ...         ("A", "C", 17),
+    ...         ("A", "D", 14),
+    ...         ("B", "A", 3),
+    ...         ("B", "C", 12),
+    ...         ("B", "D", 16),
+    ...         ("C", "A", 13),
+    ...         ("C", "B", 12),
+    ...         ("C", "D", 4),
+    ...         ("D", "A", 14),
+    ...         ("D", "B", 15),
+    ...         ("D", "C", 2),
+    ...     }
+    ... )
     >>> cycle = approx.greedy_tsp(G, source="D")
     >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
     >>> cycle
@@ -1114,11 +1127,22 @@ def simulated_annealing_tsp(
     --------
     >>> from networkx.algorithms import approximation as approx
     >>> G = nx.DiGraph()
-    >>> G.add_weighted_edges_from({
-    ...     ("A", "B", 3), ("A", "C", 17), ("A", "D", 14), ("B", "A", 3),
-    ...     ("B", "C", 12), ("B", "D", 16), ("C", "A", 13),("C", "B", 12),
-    ...     ("C", "D", 4), ("D", "A", 14), ("D", "B", 15), ("D", "C", 2)
-    ... })
+    >>> G.add_weighted_edges_from(
+    ...     {
+    ...         ("A", "B", 3),
+    ...         ("A", "C", 17),
+    ...         ("A", "D", 14),
+    ...         ("B", "A", 3),
+    ...         ("B", "C", 12),
+    ...         ("B", "D", 16),
+    ...         ("C", "A", 13),
+    ...         ("C", "B", 12),
+    ...         ("C", "D", 4),
+    ...         ("D", "A", 14),
+    ...         ("D", "B", 15),
+    ...         ("D", "C", 2),
+    ...     }
+    ... )
     >>> cycle = approx.simulated_annealing_tsp(G, "greedy", source="D")
     >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
     >>> cycle
@@ -1331,11 +1355,22 @@ def threshold_accepting_tsp(
     --------
     >>> from networkx.algorithms import approximation as approx
     >>> G = nx.DiGraph()
-    >>> G.add_weighted_edges_from({
-    ...     ("A", "B", 3), ("A", "C", 17), ("A", "D", 14), ("B", "A", 3),
-    ...     ("B", "C", 12), ("B", "D", 16), ("C", "A", 13),("C", "B", 12),
-    ...     ("C", "D", 4), ("D", "A", 14), ("D", "B", 15), ("D", "C", 2)
-    ... })
+    >>> G.add_weighted_edges_from(
+    ...     {
+    ...         ("A", "B", 3),
+    ...         ("A", "C", 17),
+    ...         ("A", "D", 14),
+    ...         ("B", "A", 3),
+    ...         ("B", "C", 12),
+    ...         ("B", "D", 16),
+    ...         ("C", "A", 13),
+    ...         ("C", "B", 12),
+    ...         ("C", "D", 4),
+    ...         ("D", "A", 14),
+    ...         ("D", "B", 15),
+    ...         ("D", "C", 2),
+    ...     }
+    ... )
     >>> cycle = approx.threshold_accepting_tsp(G, "greedy", source="D")
     >>> cost = sum(G[n][nbr]["weight"] for n, nbr in nx.utils.pairwise(cycle))
     >>> cycle
diff --git a/networkx/algorithms/assortativity/mixing.py b/networkx/algorithms/assortativity/mixing.py
index 577f5da56a9..7958661e3f4 100644
--- a/networkx/algorithms/assortativity/mixing.py
+++ b/networkx/algorithms/assortativity/mixing.py
@@ -98,12 +98,12 @@ def attribute_mixing_matrix(G, attribute, nodes=None, mapping=None, normalized=T
     Examples
     --------
     >>> G = nx.path_graph(3)
-    >>> gender = {0: 'male', 1: 'female', 2: 'female'}
-    >>> nx.set_node_attributes(G, gender, 'gender')
-    >>> mapping = {'male': 0, 'female': 1}
-    >>> mix_mat = nx.attribute_mixing_matrix(G, 'gender', mapping=mapping)
+    >>> gender = {0: "male", 1: "female", 2: "female"}
+    >>> nx.set_node_attributes(G, gender, "gender")
+    >>> mapping = {"male": 0, "female": 1}
+    >>> mix_mat = nx.attribute_mixing_matrix(G, "gender", mapping=mapping)
     >>> # mixing from male nodes to female nodes
-    >>> mix_mat[mapping['male'], mapping['female']]
+    >>> mix_mat[mapping["male"], mapping["female"]]
     0.25
     """
     d = attribute_mixing_dict(G, attribute, nodes)
@@ -201,7 +201,7 @@ def degree_mixing_matrix(
     have that degree, use `mapping` as follows,
 
     >>> max_degree = max(deg for n, deg in G.degree)
-    >>> mapping = {x: x for x in range(max_degree + 1)} # identity mapping
+    >>> mapping = {x: x for x in range(max_degree + 1)}  # identity mapping
     >>> mix_mat = nx.degree_mixing_matrix(G, mapping=mapping)
     >>> mix_mat[3, 1]  # mixing from node degree 3 to node degree 1
     0.5
diff --git a/networkx/algorithms/bipartite/projection.py b/networkx/algorithms/bipartite/projection.py
index e0afe58a870..55544c4acbc 100644
--- a/networkx/algorithms/bipartite/projection.py
+++ b/networkx/algorithms/bipartite/projection.py
@@ -263,7 +263,6 @@ def collaboration_weighted_projected_graph(B, nodes):
     [0, 2, 4, 5]
     >>> for edge in sorted(G.edges(data=True)):
     ...     print(edge)
-    ...
     (0, 2, {'weight': 0.5})
     (0, 5, {'weight': 0.5})
     (2, 4, {'weight': 1.0})
@@ -451,22 +450,18 @@ def generic_weighted_projected_graph(B, nodes, weight_function=None):
     ...     unbrs = set(G[u])
     ...     vnbrs = set(G[v])
     ...     return float(len(unbrs & vnbrs)) / len(unbrs | vnbrs)
-    ...
     >>> def my_weight(G, u, v, weight="weight"):
     ...     w = 0
     ...     for nbr in set(G[u]) & set(G[v]):
     ...         w += G[u][nbr].get(weight, 1) + G[v][nbr].get(weight, 1)
     ...     return w
-    ...
     >>> # A complete bipartite graph with 4 nodes and 4 edges
     >>> B = nx.complete_bipartite_graph(2, 2)
     >>> # Add some arbitrary weight to the edges
     >>> for i, (u, v) in enumerate(B.edges()):
     ...     B.edges[u, v]["weight"] = i + 1
-    ...
     >>> for edge in B.edges(data=True):
     ...     print(edge)
-    ...
     (0, 2, {'weight': 1})
     (0, 3, {'weight': 2})
     (1, 2, {'weight': 3})
@@ -476,14 +471,10 @@ def generic_weighted_projected_graph(B, nodes, weight_function=None):
     >>> print(list(G.edges(data=True)))
     [(0, 1, {'weight': 2})]
     >>> # To specify a custom weight function use the weight_function parameter
-    >>> G = bipartite.generic_weighted_projected_graph(
-    ...     B, [0, 1], weight_function=jaccard
-    ... )
+    >>> G = bipartite.generic_weighted_projected_graph(B, [0, 1], weight_function=jaccard)
     >>> print(list(G.edges(data=True)))
     [(0, 1, {'weight': 1.0})]
-    >>> G = bipartite.generic_weighted_projected_graph(
-    ...     B, [0, 1], weight_function=my_weight
-    ... )
+    >>> G = bipartite.generic_weighted_projected_graph(B, [0, 1], weight_function=my_weight)
     >>> print(list(G.edges(data=True)))
     [(0, 1, {'weight': 10})]
 
diff --git a/networkx/algorithms/clique.py b/networkx/algorithms/clique.py
index cb7210854e0..0b4d156e900 100644
--- a/networkx/algorithms/clique.py
+++ b/networkx/algorithms/clique.py
@@ -437,8 +437,9 @@ def make_max_clique_graph(G, create_using=None):
     This function behaves like the following code::
 
         import networkx as nx
+
         G = nx.make_clique_bipartite(G)
-        cliques = [v for v in G.nodes() if G.nodes[v]['bipartite'] == 0]
+        cliques = [v for v in G.nodes() if G.nodes[v]["bipartite"] == 0]
         G = nx.bipartite.projected_graph(G, cliques)
         G = nx.relabel_nodes(G, {-v: v - 1 for v in G})
 
diff --git a/networkx/algorithms/components/strongly_connected.py b/networkx/algorithms/components/strongly_connected.py
index 97370425f17..5f89cb1278c 100644
--- a/networkx/algorithms/components/strongly_connected.py
+++ b/networkx/algorithms/components/strongly_connected.py
@@ -39,10 +39,7 @@ def strongly_connected_components(G):
 
     >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
     >>> nx.add_cycle(G, [10, 11, 12])
-    >>> [
-    ...     len(c)
-    ...     for c in sorted(nx.strongly_connected_components(G), key=len, reverse=True)
-    ... ]
+    >>> [len(c) for c in sorted(nx.strongly_connected_components(G), key=len, reverse=True)]
     [4, 3]
 
     If you only want the largest component, it's more efficient to
@@ -277,7 +274,9 @@ def number_strongly_connected_components(G):
 
     Examples
     --------
-    >>> G = nx.DiGraph([(0, 1), (1, 2), (2, 0), (2, 3), (4, 5), (3, 4), (5, 6), (6, 3), (6, 7)])
+    >>> G = nx.DiGraph(
+    ...     [(0, 1), (1, 2), (2, 0), (2, 3), (4, 5), (3, 4), (5, 6), (6, 3), (6, 7)]
+    ... )
     >>> nx.number_strongly_connected_components(G)
     3
 
@@ -391,7 +390,7 @@ def condensation(G, scc=None):
     >>> H = nx.condensation(G)
     >>> H.nodes.data()
     NodeDataView({0: {'members': {0, 1, 2, 3}}, 1: {'members': {4, 5, 6, 7}}})
-    >>> H.graph['mapping']
+    >>> H.graph["mapping"]
     {0: 0, 1: 0, 2: 0, 3: 0, 4: 1, 5: 1, 6: 1, 7: 1}
 
     Contracting a complete graph into one single SCC.
diff --git a/networkx/algorithms/components/weakly_connected.py b/networkx/algorithms/components/weakly_connected.py
index 7437fad8242..499c2ba742c 100644
--- a/networkx/algorithms/components/weakly_connected.py
+++ b/networkx/algorithms/components/weakly_connected.py
@@ -36,10 +36,7 @@ def weakly_connected_components(G):
 
     >>> G = nx.path_graph(4, create_using=nx.DiGraph())
     >>> nx.add_path(G, [10, 11, 12])
-    >>> [
-    ...     len(c)
-    ...     for c in sorted(nx.weakly_connected_components(G), key=len, reverse=True)
-    ... ]
+    >>> [len(c) for c in sorted(nx.weakly_connected_components(G), key=len, reverse=True)]
     [4, 3]
 
     If you only want the largest component, it's more efficient to
diff --git a/networkx/algorithms/connectivity/connectivity.py b/networkx/algorithms/connectivity/connectivity.py
index 06f035feb4d..ea96dbf2447 100644
--- a/networkx/algorithms/connectivity/connectivity.py
+++ b/networkx/algorithms/connectivity/connectivity.py
@@ -118,7 +118,6 @@ def local_node_connectivity(
     >>> # You also have to explicitly import the function for
     >>> # building the auxiliary digraph from the connectivity package
     >>> from networkx.algorithms.connectivity import build_auxiliary_node_connectivity
-    ...
     >>> H = build_auxiliary_node_connectivity(G)
     >>> # And the function for building the residual network from the
     >>> # flow package
@@ -131,7 +130,6 @@ def local_node_connectivity(
     >>> for u, v in itertools.combinations(G, 2):
     ...     k = local_node_connectivity(G, u, v, auxiliary=H, residual=R)
     ...     result[u][v] = k
-    ...
     >>> all(result[u][v] == 5 for u, v in itertools.combinations(G, 2))
     True
 
diff --git a/networkx/algorithms/dag.py b/networkx/algorithms/dag.py
index 70cdd8d968d..04c76424feb 100644
--- a/networkx/algorithms/dag.py
+++ b/networkx/algorithms/dag.py
@@ -377,7 +377,7 @@ def lexicographical_topological_sort(G, key=None):
     The sort will fail for any graph with integer and string nodes. Comparison of integer to strings
     is not defined in python.  Is 3 greater or less than 'red'?
 
-    >>> DG = nx.DiGraph([(1, 'red'), (3, 'red'), (1, 'green'), (2, 'blue')])
+    >>> DG = nx.DiGraph([(1, "red"), (3, "red"), (1, "green"), (2, "blue")])
     >>> list(nx.lexicographical_topological_sort(DG))
     Traceback (most recent call last):
     ...
@@ -853,7 +853,7 @@ def transitive_reduction(G):
     To perform transitive reduction on a DiGraph and transfer node/edge data:
 
     >>> DG = nx.DiGraph()
-    >>> DG.add_edges_from([(1, 2), (2, 3), (1, 3)], color='red')
+    >>> DG.add_edges_from([(1, 2), (2, 3), (1, 3)], color="red")
     >>> TR = nx.transitive_reduction(DG)
     >>> TR.add_nodes_from(DG.nodes(data=True))
     >>> TR.add_edges_from((u, v, DG.edges[u, v]) for u, v in TR.edges)
@@ -988,7 +988,7 @@ def dag_longest_path(G, weight="weight", default_weight=1, topo_order=None):
 
     Examples
     --------
-    >>> DG = nx.DiGraph([(0, 1, {'cost':1}), (1, 2, {'cost':1}), (0, 2, {'cost':42})])
+    >>> DG = nx.DiGraph([(0, 1, {"cost": 1}), (1, 2, {"cost": 1}), (0, 2, {"cost": 42})])
     >>> list(nx.all_simple_paths(DG, 0, 2))
     [[0, 1, 2], [0, 2]]
     >>> nx.dag_longest_path(DG)
@@ -1078,7 +1078,7 @@ def dag_longest_path_length(G, weight="weight", default_weight=1):
 
     Examples
     --------
-    >>> DG = nx.DiGraph([(0, 1, {'cost':1}), (1, 2, {'cost':1}), (0, 2, {'cost':42})])
+    >>> DG = nx.DiGraph([(0, 1, {"cost": 1}), (1, 2, {"cost": 1}), (0, 2, {"cost": 42})])
     >>> list(nx.all_simple_paths(DG, 0, 2))
     [[0, 1, 2], [0, 2]]
     >>> nx.dag_longest_path_length(DG)
diff --git a/networkx/algorithms/flow/maxflow.py b/networkx/algorithms/flow/maxflow.py
index f196fe31d46..96bca029f00 100644
--- a/networkx/algorithms/flow/maxflow.py
+++ b/networkx/algorithms/flow/maxflow.py
@@ -140,9 +140,7 @@ def maximum_flow(flowG, _s, _t, capacity="capacity", flow_func=None, **kwargs):
     maximum flow by using the flow_func parameter.
 
     >>> from networkx.algorithms.flow import shortest_augmenting_path
-    >>> flow_value == nx.maximum_flow(G, "x", "y", flow_func=shortest_augmenting_path)[
-    ...     0
-    ... ]
+    >>> flow_value == nx.maximum_flow(G, "x", "y", flow_func=shortest_augmenting_path)[0]
     True
 
     """
@@ -281,9 +279,7 @@ def maximum_flow_value(flowG, _s, _t, capacity="capacity", flow_func=None, **kwa
     maximum flow by using the flow_func parameter.
 
     >>> from networkx.algorithms.flow import shortest_augmenting_path
-    >>> flow_value == nx.maximum_flow_value(
-    ...     G, "x", "y", flow_func=shortest_augmenting_path
-    ... )
+    >>> flow_value == nx.maximum_flow_value(G, "x", "y", flow_func=shortest_augmenting_path)
     True
 
     """
@@ -582,9 +578,7 @@ def minimum_cut_value(flowG, _s, _t, capacity="capacity", flow_func=None, **kwar
     minimum cut by using the flow_func parameter.
 
     >>> from networkx.algorithms.flow import shortest_augmenting_path
-    >>> cut_value == nx.minimum_cut_value(
-    ...     G, "x", "y", flow_func=shortest_augmenting_path
-    ... )
+    >>> cut_value == nx.minimum_cut_value(G, "x", "y", flow_func=shortest_augmenting_path)
     True
 
     """
diff --git a/networkx/algorithms/graph_hashing.py b/networkx/algorithms/graph_hashing.py
index bbe80671e85..bf78b7fb707 100644
--- a/networkx/algorithms/graph_hashing.py
+++ b/networkx/algorithms/graph_hashing.py
@@ -234,13 +234,9 @@ def weisfeiler_lehman_subgraph_hashes(
     Finding similar nodes in different graphs:
 
     >>> G1 = nx.Graph()
-    >>> G1.add_edges_from([
-    ...     (1, 2), (2, 3), (2, 4), (3, 5), (4, 6), (5, 7), (6, 7)
-    ... ])
+    >>> G1.add_edges_from([(1, 2), (2, 3), (2, 4), (3, 5), (4, 6), (5, 7), (6, 7)])
     >>> G2 = nx.Graph()
-    >>> G2.add_edges_from([
-    ...     (1, 3), (2, 3), (1, 6), (1, 5), (4, 6)
-    ... ])
+    >>> G2.add_edges_from([(1, 3), (2, 3), (1, 6), (1, 5), (4, 6)])
     >>> g1_hashes = nx.weisfeiler_lehman_subgraph_hashes(G1, iterations=3, digest_size=8)
     >>> g2_hashes = nx.weisfeiler_lehman_subgraph_hashes(G2, iterations=3, digest_size=8)
 
diff --git a/networkx/algorithms/isomorphism/matchhelpers.py b/networkx/algorithms/isomorphism/matchhelpers.py
index 5239ed77e6c..8185f34ebde 100644
--- a/networkx/algorithms/isomorphism/matchhelpers.py
+++ b/networkx/algorithms/isomorphism/matchhelpers.py
@@ -311,7 +311,6 @@ def generic_multiedge_match(attr, default, op):
     >>> nm = generic_node_match("weight", 1.0, isclose)
     >>> nm = generic_node_match("color", "red", eq)
     >>> nm = generic_node_match(["weight", "color"], [1.0, "red"], [isclose, eq])
-    ...
 
     """
 
diff --git a/networkx/algorithms/isomorphism/temporalisomorphvf2.py b/networkx/algorithms/isomorphism/temporalisomorphvf2.py
index 62cacc77887..b78ecf149f5 100644
--- a/networkx/algorithms/isomorphism/temporalisomorphvf2.py
+++ b/networkx/algorithms/isomorphism/temporalisomorphvf2.py
@@ -89,9 +89,7 @@ def __init__(self, G1, G2, temporal_attribute_name, delta):
 
         >>> G2 = nx.Graph(nx.path_graph(4, create_using=nx.Graph()))
 
-        >>> GM = isomorphism.TimeRespectingGraphMatcher(
-        ...     G1, G2, "date", timedelta(days=1)
-        ... )
+        >>> GM = isomorphism.TimeRespectingGraphMatcher(G1, G2, "date", timedelta(days=1))
         """
         self.temporal_attribute_name = temporal_attribute_name
         self.delta = delta
@@ -158,9 +156,7 @@ def __init__(self, G1, G2, temporal_attribute_name, delta):
 
         >>> G2 = nx.DiGraph(nx.path_graph(4, create_using=nx.DiGraph()))
 
-        >>> GM = isomorphism.TimeRespectingDiGraphMatcher(
-        ...     G1, G2, "date", timedelta(days=1)
-        ... )
+        >>> GM = isomorphism.TimeRespectingDiGraphMatcher(G1, G2, "date", timedelta(days=1))
         """
         self.temporal_attribute_name = temporal_attribute_name
         self.delta = delta
diff --git a/networkx/algorithms/minors/contraction.py b/networkx/algorithms/minors/contraction.py
index 08d1b3497e6..ed29a7ac7c5 100644
--- a/networkx/algorithms/minors/contraction.py
+++ b/networkx/algorithms/minors/contraction.py
@@ -68,8 +68,9 @@ def equivalence_classes(iterable, relation):
     `X` and a function implementation of `R`.
 
     >>> X = set(range(10))
-    >>> def mod3(x, y): return (x - y) % 3 == 0
-    >>> equivalence_classes(X, mod3)    # doctest: +SKIP
+    >>> def mod3(x, y):
+    ...     return (x - y) % 3 == 0
+    >>> equivalence_classes(X, mod3)  # doctest: +SKIP
     {frozenset({1, 4, 7}), frozenset({8, 2, 5}), frozenset({0, 9, 3, 6})}
     """
     # For simplicity of implementation, we initialize the return value as a
@@ -202,9 +203,7 @@ def quotient_graph(
     are equivalent if they are not adjacent but have the same neighbor set.
 
     >>> G = nx.complete_bipartite_graph(2, 3)
-    >>> same_neighbors = lambda u, v: (
-    ...     u not in G[v] and v not in G[u] and G[u] == G[v]
-    ... )
+    >>> same_neighbors = lambda u, v: (u not in G[v] and v not in G[u] and G[u] == G[v])
     >>> Q = nx.quotient_graph(G, same_neighbors)
     >>> K2 = nx.complete_graph(2)
     >>> nx.is_isomorphic(Q, K2)
diff --git a/networkx/algorithms/non_randomness.py b/networkx/algorithms/non_randomness.py
index 88e8fd08e90..d0e9acbf666 100644
--- a/networkx/algorithms/non_randomness.py
+++ b/networkx/algorithms/non_randomness.py
@@ -57,7 +57,7 @@ def non_randomness(G, k=None, weight="weight"):
     --------
     >>> G = nx.karate_club_graph()
     >>> nr, nr_rd = nx.non_randomness(G, 2)
-    >>> nr, nr_rd = nx.non_randomness(G, 2, 'weight')
+    >>> nr, nr_rd = nx.non_randomness(G, 2, "weight")
 
     Notes
     -----
diff --git a/networkx/algorithms/operators/all.py b/networkx/algorithms/operators/all.py
index 4e0c2173b9c..e6f4d60b040 100644
--- a/networkx/algorithms/operators/all.py
+++ b/networkx/algorithms/operators/all.py
@@ -270,8 +270,11 @@ def intersection_all(graphs):
 
     >>> gh = nx.intersection_all([g, h])
 
-    >>> new_node_attr = {n: min(*(anyG.nodes[n].get('capacity', float('inf')) for anyG in [g, h])) for n in gh}
-    >>> nx.set_node_attributes(gh, new_node_attr, 'new_capacity')
+    >>> new_node_attr = {
+    ...     n: min(*(anyG.nodes[n].get("capacity", float("inf")) for anyG in [g, h]))
+    ...     for n in gh
+    ... }
+    >>> nx.set_node_attributes(gh, new_node_attr, "new_capacity")
     >>> gh.nodes(data=True)
     NodeDataView({0: {'new_capacity': 2}, 1: {'new_capacity': 3}})
 
diff --git a/networkx/algorithms/operators/binary.py b/networkx/algorithms/operators/binary.py
index 9a9b5891e9a..2b69aaf084d 100644
--- a/networkx/algorithms/operators/binary.py
+++ b/networkx/algorithms/operators/binary.py
@@ -336,30 +336,34 @@ def compose(G, H):
     By default, the attributes from `H` take precedent over attributes from `G`.
     If you prefer another way of combining attributes, you can update them after the compose operation:
 
-    >>> G = nx.Graph([(0, 1, {'weight': 2.0}), (3, 0, {'weight': 100.0})])
-    >>> H = nx.Graph([(0, 1, {'weight': 10.0}), (1, 2, {'weight': -1.0})])
-    >>> nx.set_node_attributes(G, {0: 'dark', 1: 'light', 3: 'black'}, name='color')
-    >>> nx.set_node_attributes(H, {0: 'green', 1: 'orange', 2: 'yellow'}, name='color')
+    >>> G = nx.Graph([(0, 1, {"weight": 2.0}), (3, 0, {"weight": 100.0})])
+    >>> H = nx.Graph([(0, 1, {"weight": 10.0}), (1, 2, {"weight": -1.0})])
+    >>> nx.set_node_attributes(G, {0: "dark", 1: "light", 3: "black"}, name="color")
+    >>> nx.set_node_attributes(H, {0: "green", 1: "orange", 2: "yellow"}, name="color")
     >>> GcomposeH = nx.compose(G, H)
 
     Normally, color attribute values of nodes of GcomposeH come from H. We can workaround this as follows:
 
-    >>> node_data = {n: G.nodes[n]['color'] + " " + H.nodes[n]['color'] for n in G.nodes & H.nodes}
-    >>> nx.set_node_attributes(GcomposeH, node_data, 'color')
-    >>> print(GcomposeH.nodes[0]['color'])
+    >>> node_data = {
+    ...     n: G.nodes[n]["color"] + " " + H.nodes[n]["color"] for n in G.nodes & H.nodes
+    ... }
+    >>> nx.set_node_attributes(GcomposeH, node_data, "color")
+    >>> print(GcomposeH.nodes[0]["color"])
     dark green
 
-    >>> print(GcomposeH.nodes[3]['color'])
+    >>> print(GcomposeH.nodes[3]["color"])
     black
 
     Similarly, we can update edge attributes after the compose operation in a way we prefer:
 
-    >>> edge_data = {e: G.edges[e]['weight'] * H.edges[e]['weight'] for e in G.edges & H.edges}
-    >>> nx.set_edge_attributes(GcomposeH, edge_data, 'weight')
-    >>> print(GcomposeH.edges[(0, 1)]['weight'])
+    >>> edge_data = {
+    ...     e: G.edges[e]["weight"] * H.edges[e]["weight"] for e in G.edges & H.edges
+    ... }
+    >>> nx.set_edge_attributes(GcomposeH, edge_data, "weight")
+    >>> print(GcomposeH.edges[(0, 1)]["weight"])
     20.0
 
-    >>> print(GcomposeH.edges[(3, 0)]['weight'])
+    >>> print(GcomposeH.edges[(3, 0)]["weight"])
     100.0
     """
     return nx.compose_all([G, H])
diff --git a/networkx/algorithms/operators/unary.py b/networkx/algorithms/operators/unary.py
index 42309ee9ff0..9b1480a8012 100644
--- a/networkx/algorithms/operators/unary.py
+++ b/networkx/algorithms/operators/unary.py
@@ -28,7 +28,7 @@ def complement(G):
     --------
     >>> G = nx.Graph([(1, 2), (1, 3), (2, 3), (3, 4), (3, 5)])
     >>> G_complement = nx.complement(G)
-    >>> G_complement.edges() # This shows the edges of the complemented graph
+    >>> G_complement.edges()  # This shows the edges of the complemented graph
     EdgeView([(1, 4), (1, 5), (2, 4), (2, 5), (4, 5)])
 
     """
diff --git a/networkx/algorithms/shortest_paths/dense.py b/networkx/algorithms/shortest_paths/dense.py
index 45fcac3249f..26e5503d7f9 100644
--- a/networkx/algorithms/shortest_paths/dense.py
+++ b/networkx/algorithms/shortest_paths/dense.py
@@ -233,7 +233,7 @@ def floyd_warshall(G, weight="weight"):
     --------
     >>> G = nx.DiGraph()
     >>> G.add_weighted_edges_from([(0, 1, 5), (1, 2, 2), (2, 3, -3), (1, 3, 10), (3, 2, 8)])
-    >>> fw = nx.floyd_warshall(G, weight='weight')
+    >>> fw = nx.floyd_warshall(G, weight="weight")
     >>> results = {a: dict(b) for a, b in fw.items()}
     >>> print(results)
     {0: {0: 0, 1: 5, 2: 7, 3: 4}, 1: {1: 0, 2: 2, 3: -1, 0: inf}, 2: {2: 0, 3: -3, 0: inf, 1: inf}, 3: {3: 0, 2: 8, 0: inf, 1: inf}}
diff --git a/networkx/algorithms/shortest_paths/generic.py b/networkx/algorithms/shortest_paths/generic.py
index 6d8d8c823e5..aa5fc5c89c1 100644
--- a/networkx/algorithms/shortest_paths/generic.py
+++ b/networkx/algorithms/shortest_paths/generic.py
@@ -106,13 +106,13 @@ def shortest_path(G, source=None, target=None, weight=None, method="dijkstra"):
     >>> print(nx.shortest_path(G, source=0, target=4))
     [0, 1, 2, 3, 4]
     >>> p = nx.shortest_path(G, source=0)  # target not specified
-    >>> p[3] # shortest path from source=0 to target=3
+    >>> p[3]  # shortest path from source=0 to target=3
     [0, 1, 2, 3]
     >>> p = nx.shortest_path(G, target=4)  # source not specified
-    >>> p[1] # shortest path from source=1 to target=4
+    >>> p[1]  # shortest path from source=1 to target=4
     [1, 2, 3, 4]
     >>> p = dict(nx.shortest_path(G))  # source, target not specified
-    >>> p[2][4] # shortest path from source=2 to target=4
+    >>> p[2][4]  # shortest path from source=2 to target=4
     [2, 3, 4]
 
     Notes
diff --git a/networkx/algorithms/shortest_paths/weighted.py b/networkx/algorithms/shortest_paths/weighted.py
index e013fe24f83..6299d276cb1 100644
--- a/networkx/algorithms/shortest_paths/weighted.py
+++ b/networkx/algorithms/shortest_paths/weighted.py
@@ -133,7 +133,10 @@ def dijkstra_path(G, source, target, weight="weight"):
     >>> G.add_weighted_edges_from([(1, 2, 0.75), (1, 2, 0.5), (2, 3, 0.5), (1, 3, 1.5)])
     >>> nodes = nx.dijkstra_path(G, 1, 3)
     >>> edges = nx.utils.pairwise(nodes)
-    >>> list((u, v, min(G[u][v], key=lambda k: G[u][v][k].get('weight', 1))) for u, v in edges)
+    >>> list(
+    ...     (u, v, min(G[u][v], key=lambda k: G[u][v][k].get("weight", 1)))
+    ...     for u, v in edges
+    ... )
     [(1, 2, 1), (2, 3, 0)]
 
     Notes
diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index e36d23dcb83..68625d009ea 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -1232,9 +1232,9 @@ def simrank(G, u, v):
             in_neighbors_u = G.predecessors(u)
             in_neighbors_v = G.predecessors(v)
             scale = C / (len(in_neighbors_u) * len(in_neighbors_v))
-            return scale * sum(simrank(G, w, x)
-                               for w, x in product(in_neighbors_u,
-                                                   in_neighbors_v))
+            return scale * sum(
+                simrank(G, w, x) for w, x in product(in_neighbors_u, in_neighbors_v)
+            )
 
     where ``G`` is the graph, ``u`` is the source, ``v`` is the target,
     and ``C`` is a float decay or importance factor between 0 and 1.
@@ -1703,7 +1703,9 @@ def generate_random_paths(
     >>> G = nx.star_graph(3)
     >>> index_map = {}
     >>> random_path = nx.generate_random_paths(G, 3, index_map=index_map)
-    >>> paths_containing_node_0 = [random_path[path_idx] for path_idx in index_map.get(0, [])]
+    >>> paths_containing_node_0 = [
+    ...     random_path[path_idx] for path_idx in index_map.get(0, [])
+    ... ]
 
     References
     ----------
diff --git a/networkx/algorithms/simple_paths.py b/networkx/algorithms/simple_paths.py
index be0890339e7..1bd2feb707b 100644
--- a/networkx/algorithms/simple_paths.py
+++ b/networkx/algorithms/simple_paths.py
@@ -319,7 +319,7 @@ def all_simple_edge_paths(G, source, target, cutoff=None):
         >>> G.add_node(0)
         >>> paths = list(nx.all_simple_edge_paths(G, 0, 0))
         >>> for path in paths:
-        ...     print (path)
+        ...     print(path)
         []
         >>> len(paths)
         1
diff --git a/networkx/algorithms/summarization.py b/networkx/algorithms/summarization.py
index f3364e32ee7..bdabbaaf039 100644
--- a/networkx/algorithms/summarization.py
+++ b/networkx/algorithms/summarization.py
@@ -492,13 +492,13 @@ def snap_aggregation(
     >>> for node in nodes:
     ...     attributes = nodes[node]
     ...     G.add_node(node, **attributes)
-    ...
     >>> for source, target, type in edges:
     ...     G.add_edge(source, target, type=type)
-    ...
-    >>> node_attributes = ('color', )
-    >>> edge_attributes = ('type', )
-    >>> summary_graph = nx.snap_aggregation(G, node_attributes=node_attributes, edge_attributes=edge_attributes)
+    >>> node_attributes = ("color",)
+    >>> edge_attributes = ("type",)
+    >>> summary_graph = nx.snap_aggregation(
+    ...     G, node_attributes=node_attributes, edge_attributes=edge_attributes
+    ... )
 
     Notes
     -----
diff --git a/networkx/algorithms/threshold.py b/networkx/algorithms/threshold.py
index 1eb35a2c528..374e9693ecf 100644
--- a/networkx/algorithms/threshold.py
+++ b/networkx/algorithms/threshold.py
@@ -394,7 +394,7 @@ def find_threshold_graph(G, create_using=None):
     >>> from networkx.algorithms.threshold import find_threshold_graph
     >>> G = nx.barbell_graph(3, 3)
     >>> T = find_threshold_graph(G)
-    >>> T.nodes # may vary
+    >>> T.nodes  # may vary
     NodeView((7, 8, 5, 6))
 
     References
diff --git a/networkx/algorithms/time_dependent.py b/networkx/algorithms/time_dependent.py
index 597a3d157f3..d67cdcf0b8e 100644
--- a/networkx/algorithms/time_dependent.py
+++ b/networkx/algorithms/time_dependent.py
@@ -55,10 +55,10 @@ def cd_index(G, node, time_delta, *, time="time", weight=None):
     >>> G = nx.DiGraph()
     >>> nodes = {
     ...     1: {"time": datetime(2015, 1, 1)},
-    ...     2: {"time": datetime(2012, 1, 1), 'weight': 4},
+    ...     2: {"time": datetime(2012, 1, 1), "weight": 4},
     ...     3: {"time": datetime(2010, 1, 1)},
     ...     4: {"time": datetime(2008, 1, 1)},
-    ...     5: {"time": datetime(2014, 1, 1)}
+    ...     5: {"time": datetime(2014, 1, 1)},
     ... }
     >>> G.add_nodes_from([(n, nodes[n]) for n in nodes])
     >>> edges = [(1, 3), (1, 4), (2, 3), (3, 4), (3, 5)]
diff --git a/networkx/algorithms/traversal/breadth_first_search.py b/networkx/algorithms/traversal/breadth_first_search.py
index a4e5c951727..d7aba232dde 100644
--- a/networkx/algorithms/traversal/breadth_first_search.py
+++ b/networkx/algorithms/traversal/breadth_first_search.py
@@ -516,7 +516,7 @@ def bfs_labeled_edges(G, sources):
 
     Examples
     --------
-    >>> G = nx.cycle_graph(4, create_using = nx.DiGraph)
+    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph)
     >>> list(nx.bfs_labeled_edges(G, 0))
     [(0, 1, 'tree'), (1, 2, 'tree'), (2, 3, 'tree'), (3, 0, 'reverse')]
     >>> G = nx.complete_graph(3)
diff --git a/networkx/algorithms/triads.py b/networkx/algorithms/triads.py
index c2cdf2e8008..74b2f51b9db 100644
--- a/networkx/algorithms/triads.py
+++ b/networkx/algorithms/triads.py
@@ -155,7 +155,6 @@ def triadic_census(G, nodelist=None):
     >>> triadic_census = nx.triadic_census(G)
     >>> for key, value in triadic_census.items():
     ...     print(f"{key}: {value}")
-    ...
     003: 0
     012: 0
     102: 0
@@ -427,9 +426,9 @@ def triads_by_type(G):
     --------
     >>> G = nx.DiGraph([(1, 2), (1, 3), (2, 3), (3, 1), (5, 6), (5, 4), (6, 7)])
     >>> dict = nx.triads_by_type(G)
-    >>> dict['120C'][0].edges()
+    >>> dict["120C"][0].edges()
     OutEdgeView([(1, 2), (1, 3), (2, 3), (3, 1)])
-    >>> dict['012'][0].edges()
+    >>> dict["012"][0].edges()
     OutEdgeView([(1, 2)])
 
     References
diff --git a/networkx/classes/digraph.py b/networkx/classes/digraph.py
index 988ed599892..945643776b4 100644
--- a/networkx/classes/digraph.py
+++ b/networkx/classes/digraph.py
@@ -1026,7 +1026,7 @@ def in_edges(self):
         Examples
         --------
         >>> G = nx.DiGraph()
-        >>> G.add_edge(1, 2, color='blue')
+        >>> G.add_edge(1, 2, color="blue")
         >>> G.in_edges()
         InEdgeView([(1, 2)])
         >>> G.in_edges(nbunch=2)
diff --git a/networkx/classes/graph.py b/networkx/classes/graph.py
index e149ab2eeb3..02d332be1a6 100644
--- a/networkx/classes/graph.py
+++ b/networkx/classes/graph.py
@@ -1211,20 +1211,12 @@ def update(self, edges=None, nodes=None):
         >>> DG = nx.DiGraph()
         >>> # dict-of-dict-of-attribute
         >>> adj = {1: {2: 1.3, 3: 0.7}, 2: {1: 1.4}, 3: {1: 0.7}}
-        >>> e = [
-        ...     (u, v, {"weight": d})
-        ...     for u, nbrs in adj.items()
-        ...     for v, d in nbrs.items()
-        ... ]
+        >>> e = [(u, v, {"weight": d}) for u, nbrs in adj.items() for v, d in nbrs.items()]
         >>> DG.update(edges=e, nodes=adj)
 
         >>> # dict-of-dict-of-dict
         >>> adj = {1: {2: {"weight": 1.3}, 3: {"color": 0.7, "weight": 1.2}}}
-        >>> e = [
-        ...     (u, v, {"weight": d})
-        ...     for u, nbrs in adj.items()
-        ...     for v, d in nbrs.items()
-        ... ]
+        >>> e = [(u, v, {"weight": d}) for u, nbrs in adj.items() for v, d in nbrs.items()]
         >>> DG.update(edges=e, nodes=adj)
 
         >>> # predecessor adjacency (dict-of-set)
@@ -1800,14 +1792,22 @@ def subgraph(self, nodes):
             SG = G.__class__()
             SG.add_nodes_from((n, G.nodes[n]) for n in largest_wcc)
             if SG.is_multigraph():
-                SG.add_edges_from((n, nbr, key, d)
-                    for n, nbrs in G.adj.items() if n in largest_wcc
-                    for nbr, keydict in nbrs.items() if nbr in largest_wcc
-                    for key, d in keydict.items())
+                SG.add_edges_from(
+                    (n, nbr, key, d)
+                    for n, nbrs in G.adj.items()
+                    if n in largest_wcc
+                    for nbr, keydict in nbrs.items()
+                    if nbr in largest_wcc
+                    for key, d in keydict.items()
+                )
             else:
-                SG.add_edges_from((n, nbr, d)
-                    for n, nbrs in G.adj.items() if n in largest_wcc
-                    for nbr, d in nbrs.items() if nbr in largest_wcc)
+                SG.add_edges_from(
+                    (n, nbr, d)
+                    for n, nbrs in G.adj.items()
+                    if n in largest_wcc
+                    for nbr, d in nbrs.items()
+                    if nbr in largest_wcc
+                )
             SG.graph.update(G.graph)
 
         Examples
diff --git a/networkx/classes/graphviews.py b/networkx/classes/graphviews.py
index 3fb08df08e3..275bbd71c24 100644
--- a/networkx/classes/graphviews.py
+++ b/networkx/classes/graphviews.py
@@ -180,7 +180,6 @@ def subgraph_view(G, *, filter_node=no_filter, filter_edge=no_filter):
 
     >>> def filter_node(n1):
     ...     return n1 != 5
-    ...
     >>> view = nx.subgraph_view(G, filter_node=filter_node)
     >>> view.nodes()
     NodeView((0, 1, 2, 3, 4))
@@ -191,12 +190,15 @@ def subgraph_view(G, *, filter_node=no_filter, filter_edge=no_filter):
     >>> G[3][4]["cross_me"] = False
     >>> def filter_edge(n1, n2):
     ...     return G[n1][n2].get("cross_me", True)
-    ...
     >>> view = nx.subgraph_view(G, filter_edge=filter_edge)
     >>> view.edges()
     EdgeView([(0, 1), (1, 2), (2, 3), (4, 5)])
 
-    >>> view = nx.subgraph_view(G, filter_node=filter_node, filter_edge=filter_edge,)
+    >>> view = nx.subgraph_view(
+    ...     G,
+    ...     filter_node=filter_node,
+    ...     filter_edge=filter_edge,
+    ... )
     >>> view.nodes()
     NodeView((0, 1, 2, 3, 4))
     >>> view.edges()
diff --git a/networkx/classes/multidigraph.py b/networkx/classes/multidigraph.py
index fb8b1a35c40..5a278aa967f 100644
--- a/networkx/classes/multidigraph.py
+++ b/networkx/classes/multidigraph.py
@@ -639,7 +639,7 @@ def edges(self):
         >>> G = nx.MultiDiGraph()
         >>> nx.add_path(G, [0, 1, 2])
         >>> key = G.add_edge(2, 3, weight=5)
-        >>> key2 = G.add_edge(1, 2) # second edge between these nodes
+        >>> key2 = G.add_edge(1, 2)  # second edge between these nodes
         >>> [e for e in G.edges()]
         [(0, 1), (1, 2), (1, 2), (2, 3)]
         >>> list(G.edges(data=True))  # default data is {} (empty dict)
@@ -746,9 +746,9 @@ def degree(self):
         1
         >>> list(G.degree([0, 1, 2]))
         [(0, 1), (1, 2), (2, 2)]
-        >>> G.add_edge(0, 1) # parallel edge
+        >>> G.add_edge(0, 1)  # parallel edge
         1
-        >>> list(G.degree([0, 1, 2])) # parallel edges are counted
+        >>> list(G.degree([0, 1, 2]))  # parallel edges are counted
         [(0, 2), (1, 3), (2, 2)]
 
         """
@@ -797,9 +797,9 @@ def in_degree(self):
         0
         >>> list(G.in_degree([0, 1, 2]))
         [(0, 0), (1, 1), (2, 1)]
-        >>> G.add_edge(0, 1) # parallel edge
+        >>> G.add_edge(0, 1)  # parallel edge
         1
-        >>> list(G.in_degree([0, 1, 2])) # parallel edges counted
+        >>> list(G.in_degree([0, 1, 2]))  # parallel edges counted
         [(0, 0), (1, 2), (2, 1)]
 
         """
@@ -847,9 +847,9 @@ def out_degree(self):
         1
         >>> list(G.out_degree([0, 1, 2]))
         [(0, 1), (1, 1), (2, 1)]
-        >>> G.add_edge(0, 1) # parallel edge
+        >>> G.add_edge(0, 1)  # parallel edge
         1
-        >>> list(G.out_degree([0, 1, 2])) # counts parallel edges
+        >>> list(G.out_degree([0, 1, 2]))  # counts parallel edges
         [(0, 2), (1, 1), (2, 1)]
 
         """
diff --git a/networkx/classes/multigraph.py b/networkx/classes/multigraph.py
index bbf2ce24136..b21968000da 100644
--- a/networkx/classes/multigraph.py
+++ b/networkx/classes/multigraph.py
@@ -390,7 +390,7 @@ def adj(self):
         >>> G.edges[1, 2, 0]["weight"] = 3
         >>> result = set()
         >>> for edgekey, data in G[1][2].items():
-        ...     result.add(data.get('weight', 1))
+        ...     result.add(data.get("weight", 1))
         >>> result
         {1, 3}
 
diff --git a/networkx/classes/reportviews.py b/networkx/classes/reportviews.py
index 59a16243f98..264823539a6 100644
--- a/networkx/classes/reportviews.py
+++ b/networkx/classes/reportviews.py
@@ -239,11 +239,13 @@ def data(self, data=True, default=None):
         Examples
         --------
         >>> G = nx.Graph()
-        >>> G.add_nodes_from([
-        ...     (0, {"color": "red", "weight": 10}),
-        ...     (1, {"color": "blue"}),
-        ...     (2, {"color": "yellow", "weight": 2})
-        ... ])
+        >>> G.add_nodes_from(
+        ...     [
+        ...         (0, {"color": "red", "weight": 10}),
+        ...         (1, {"color": "blue"}),
+        ...         (2, {"color": "yellow", "weight": 2}),
+        ...     ]
+        ... )
 
         Accessing node data with ``data=True`` (the default) returns a
         NodeDataView mapping each node to all of its attributes:
@@ -1129,11 +1131,13 @@ def data(self, data=True, default=None, nbunch=None):
         Examples
         --------
         >>> G = nx.Graph()
-        >>> G.add_edges_from([
-        ...     (0, 1, {"dist": 3, "capacity": 20}),
-        ...     (1, 2, {"dist": 4}),
-        ...     (2, 0, {"dist": 5})
-        ... ])
+        >>> G.add_edges_from(
+        ...     [
+        ...         (0, 1, {"dist": 3, "capacity": 20}),
+        ...         (1, 2, {"dist": 4}),
+        ...         (2, 0, {"dist": 5}),
+        ...     ]
+        ... )
 
         Accessing edge data with ``data=True`` (the default) returns an
         edge data view object listing each edge with all of its attributes:
diff --git a/networkx/convert.py b/networkx/convert.py
index f62df458e07..af2847aef0c 100644
--- a/networkx/convert.py
+++ b/networkx/convert.py
@@ -278,9 +278,7 @@ def to_dict_of_dicts(G, nodelist=None, edge_data=None):
     For a more custom approach to handling edge data, try::
 
         dod = {
-            n: {
-                nbr: custom(n, nbr, dd) for nbr, dd in nbrdict.items()
-            }
+            n: {nbr: custom(n, nbr, dd) for nbr, dd in nbrdict.items()}
             for n, nbrdict in G.adj.items()
         }
 
@@ -300,9 +298,9 @@ def to_dict_of_dicts(G, nodelist=None, edge_data=None):
     >>> G = nx.Graph()
     >>> G.add_edges_from(
     ...     [
-    ...         (0, 1, {'weight': 1.0}),
-    ...         (1, 2, {'weight': 2.0}),
-    ...         (2, 0, {'weight': 1.0}),
+    ...         (0, 1, {"weight": 1.0}),
+    ...         (1, 2, {"weight": 2.0}),
+    ...         (2, 0, {"weight": 1.0}),
     ...     ]
     ... )
     >>> d = nx.to_dict_of_dicts(G)
@@ -310,7 +308,7 @@ def to_dict_of_dicts(G, nodelist=None, edge_data=None):
     {0: {1: {'weight': 1.0}, 2: {'weight': 1.0}},
      1: {0: {'weight': 1.0}, 2: {'weight': 2.0}},
      2: {1: {'weight': 2.0}, 0: {'weight': 1.0}}}
-    >>> d[1][2]['weight']
+    >>> d[1][2]["weight"]
     2.0
 
     If `edge_data` is not `None`, edge data in the original graph (if any) is
@@ -325,15 +323,15 @@ def to_dict_of_dicts(G, nodelist=None, edge_data=None):
     This also applies to MultiGraphs: edge data is preserved by default:
 
     >>> G = nx.MultiGraph()
-    >>> G.add_edge(0, 1, key='a', weight=1.0)
+    >>> G.add_edge(0, 1, key="a", weight=1.0)
     'a'
-    >>> G.add_edge(0, 1, key='b', weight=5.0)
+    >>> G.add_edge(0, 1, key="b", weight=5.0)
     'b'
     >>> d = nx.to_dict_of_dicts(G)
     >>> d  # doctest: +SKIP
     {0: {1: {'a': {'weight': 1.0}, 'b': {'weight': 5.0}}},
      1: {0: {'a': {'weight': 1.0}, 'b': {'weight': 5.0}}}}
-    >>> d[0][1]['b']['weight']
+    >>> d[0][1]["b"]["weight"]
     5.0
 
     But multi edge data is lost if `edge_data` is not `None`:
diff --git a/networkx/convert_matrix.py b/networkx/convert_matrix.py
index ae756e59934..3e9ed1f8b46 100644
--- a/networkx/convert_matrix.py
+++ b/networkx/convert_matrix.py
@@ -273,9 +273,9 @@ def to_pandas_edgelist(
     0      A      B     1       7
     1      C      E     9      10
 
-    >>> G = nx.MultiGraph([('A', 'B', {'cost': 1}), ('A', 'B', {'cost': 9})])
-    >>> df = nx.to_pandas_edgelist(G, nodelist=['A', 'C'], edge_key='ekey')
-    >>> df[['source', 'target', 'cost', 'ekey']]
+    >>> G = nx.MultiGraph([("A", "B", {"cost": 1}), ("A", "B", {"cost": 9})])
+    >>> df = nx.to_pandas_edgelist(G, nodelist=["A", "C"], edge_key="ekey")
+    >>> df[["source", "target", "cost", "ekey"]]
       source target  cost  ekey
     0      A      B     1     0
     1      A      B     9     1
@@ -736,9 +736,7 @@ def from_scipy_sparse_array(
     as the number of parallel edges joining those two vertices:
 
     >>> A = sp.sparse.csr_array([[1, 1], [1, 2]])
-    >>> G = nx.from_scipy_sparse_array(
-    ...     A, parallel_edges=True, create_using=nx.MultiGraph
-    ... )
+    >>> G = nx.from_scipy_sparse_array(A, parallel_edges=True, create_using=nx.MultiGraph)
     >>> G[1][1]
     AtlasView({0: {'weight': 1}, 1: {'weight': 1}})
 
@@ -934,7 +932,7 @@ def to_numpy_array(
     >>> G.add_edge(2, 0, weight=0)
     >>> G.add_edge(2, 1, weight=0)
     >>> G.add_edge(3, 0, weight=1)
-    >>> nx.to_numpy_array(G, nonedge=-1.)
+    >>> nx.to_numpy_array(G, nonedge=-1.0)
     array([[-1.,  2., -1.,  1.],
            [ 2., -1.,  0., -1.],
            [-1.,  0., -1.,  0.],
diff --git a/networkx/drawing/nx_pydot.py b/networkx/drawing/nx_pydot.py
index 928970d83d0..77ae7278863 100644
--- a/networkx/drawing/nx_pydot.py
+++ b/networkx/drawing/nx_pydot.py
@@ -355,9 +355,9 @@ def pydot_layout(G, prog="neato", root=None):
     If this occurs in your case, consider relabeling the nodes just
     for the layout computation using something similar to::
 
-        H = nx.convert_node_labels_to_integers(G, label_attribute='node_label')
-        H_layout = nx.nx_pydot.pydot_layout(G, prog='dot')
-        G_layout = {H.nodes[n]['node_label']: p for n, p in H_layout.items()}
+        H = nx.convert_node_labels_to_integers(G, label_attribute="node_label")
+        H_layout = nx.nx_pydot.pydot_layout(G, prog="dot")
+        G_layout = {H.nodes[n]["node_label"]: p for n, p in H_layout.items()}
 
     """
     import pydot
diff --git a/networkx/generators/classic.py b/networkx/generators/classic.py
index 14ed49ecbdb..51ff86c1da3 100644
--- a/networkx/generators/classic.py
+++ b/networkx/generators/classic.py
@@ -424,7 +424,6 @@ def circulant_graph(n, offsets, create_using=None):
     ...     (7, 8),
     ...     (8, 9),
     ... ]
-    ...
     >>> sorted(edges) == sorted(G.edges())
     True
 
@@ -444,7 +443,6 @@ def circulant_graph(n, offsets, create_using=None):
     ...     (2, 4),
     ...     (3, 4),
     ... ]
-    ...
     >>> sorted(edges) == sorted(G.edges())
     True
 
diff --git a/networkx/generators/community.py b/networkx/generators/community.py
index 5293fdf1181..5a3d31c6833 100644
--- a/networkx/generators/community.py
+++ b/networkx/generators/community.py
@@ -551,13 +551,11 @@ def stochastic_block_model(
     >>> H = nx.quotient_graph(g, g.graph["partition"], relabel=True)
     >>> for v in H.nodes(data=True):
     ...     print(round(v[1]["density"], 3))
-    ...
     0.245
     0.348
     0.405
     >>> for v in H.edges(data=True):
     ...     print(round(1.0 * v[2]["weight"] / (sizes[v[0]] * sizes[v[1]]), 3))
-    ...
     0.051
     0.022
     0.07
diff --git a/networkx/generators/directed.py b/networkx/generators/directed.py
index 025d7957dcc..38ddc80f899 100644
--- a/networkx/generators/directed.py
+++ b/networkx/generators/directed.py
@@ -54,7 +54,7 @@ def gn_graph(n, kernel=None, create_using=None, seed=None):
 
     To specify an attachment kernel, use the `kernel` keyword argument::
 
-    >>> D = nx.gn_graph(10, kernel=lambda x: x ** 1.5)  # A_k = k^1.5
+    >>> D = nx.gn_graph(10, kernel=lambda x: x**1.5)  # A_k = k^1.5
 
     References
     ----------
diff --git a/networkx/generators/geometric.py b/networkx/generators/geometric.py
index 4035a1ea5c5..468b2d36c8b 100644
--- a/networkx/generators/geometric.py
+++ b/networkx/generators/geometric.py
@@ -57,11 +57,13 @@ def geometric_edges(G, radius, p=2, *, pos_name="pos"):
     coordinates.
 
     >>> G = nx.Graph()
-    >>> G.add_nodes_from([
-    ...     (0, {"pos": (0, 0)}),
-    ...     (1, {"pos": (3, 0)}),
-    ...     (2, {"pos": (8, 0)}),
-    ... ])
+    >>> G.add_nodes_from(
+    ...     [
+    ...         (0, {"pos": (0, 0)}),
+    ...         (1, {"pos": (3, 0)}),
+    ...         (2, {"pos": (8, 0)}),
+    ...     ]
+    ... )
     >>> nx.geometric_edges(G, radius=1)
     []
     >>> nx.geometric_edges(G, radius=4)
diff --git a/networkx/generators/line.py b/networkx/generators/line.py
index 83c6481fe43..b5974a038eb 100644
--- a/networkx/generators/line.py
+++ b/networkx/generators/line.py
@@ -48,7 +48,7 @@ def line_graph(G, create_using=None):
     attributes can be copied manually:
 
     >>> G = nx.path_graph(4)
-    >>> G.add_edges_from((u, v, {"tot": u+v}) for u, v in G.edges)
+    >>> G.add_edges_from((u, v, {"tot": u + v}) for u, v in G.edges)
     >>> G.edges(data=True)
     EdgeDataView([(0, 1, {'tot': 1}), (1, 2, {'tot': 3}), (2, 3, {'tot': 5})])
     >>> H = nx.line_graph(G)
diff --git a/networkx/generators/triads.py b/networkx/generators/triads.py
index 40b0f82a210..f9713b5df33 100644
--- a/networkx/generators/triads.py
+++ b/networkx/generators/triads.py
@@ -39,8 +39,24 @@ def triad_graph(triad_name):
 
     Each string in the following tuple is a valid triad name::
 
-        ('003', '012', '102', '021D', '021U', '021C', '111D', '111U',
-         '030T', '030C', '201', '120D', '120U', '120C', '210', '300')
+        (
+            "003",
+            "012",
+            "102",
+            "021D",
+            "021U",
+            "021C",
+            "111D",
+            "111U",
+            "030T",
+            "030C",
+            "201",
+            "120D",
+            "120U",
+            "120C",
+            "210",
+            "300",
+        )
 
     Each triad name corresponds to one of the possible valid digraph on
     three nodes.
diff --git a/networkx/lazy_imports.py b/networkx/lazy_imports.py
index 5cf7576ac03..396404ba38f 100644
--- a/networkx/lazy_imports.py
+++ b/networkx/lazy_imports.py
@@ -26,9 +26,7 @@ def attach(module_name, submodules=None, submod_attrs=None):
     The typical way to call this function, replacing the above imports, is::
 
       __getattr__, __lazy_dir__, __all__ = lazy.attach(
-          __name__,
-          ['mysubmodule', 'anothersubmodule'],
-          {'foo': 'someattr'}
+          __name__, ["mysubmodule", "anothersubmodule"], {"foo": "someattr"}
       )
 
     This functionality requires Python 3.7 or higher.
@@ -149,8 +147,8 @@ def myfunc():
     fullname : str
         The full name of the package or subpackage to import.  For example::
 
-          sp = lazy.load('scipy')  # import scipy as sp
-          spla = lazy.load('scipy.linalg')  # import scipy.linalg as spla
+          sp = lazy.load("scipy")  # import scipy as sp
+          spla = lazy.load("scipy.linalg")  # import scipy.linalg as spla
 
     Returns
     -------
diff --git a/networkx/linalg/laplacianmatrix.py b/networkx/linalg/laplacianmatrix.py
index 73ce45e4ce4..13aebff4998 100644
--- a/networkx/linalg/laplacianmatrix.py
+++ b/networkx/linalg/laplacianmatrix.py
@@ -77,7 +77,13 @@ def laplacian_matrix(G, nodelist=None, weight="weight"):
      [ 0  0  0  1 -1]
      [ 0  0  0 -1  1]]
 
-    >>> edges = [(1, 2), (2, 1), (2, 4), (4, 3), (3, 4),]
+    >>> edges = [
+    ...     (1, 2),
+    ...     (2, 1),
+    ...     (2, 4),
+    ...     (4, 3),
+    ...     (3, 4),
+    ... ]
     >>> DiG = nx.DiGraph(edges)
     >>> print(nx.laplacian_matrix(DiG).toarray())
     [[ 1 -1  0  0]
@@ -156,8 +162,14 @@ def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     --------
 
     >>> import numpy as np
-    >>> np.set_printoptions(precision=4) # To print with lower precision
-    >>> edges = [(1, 2), (2, 1), (2, 4), (4, 3), (3, 4),]
+    >>> np.set_printoptions(precision=4)  # To print with lower precision
+    >>> edges = [
+    ...     (1, 2),
+    ...     (2, 1),
+    ...     (2, 4),
+    ...     (4, 3),
+    ...     (3, 4),
+    ... ]
     >>> DiG = nx.DiGraph(edges)
     >>> print(nx.normalized_laplacian_matrix(DiG).toarray())
     [[ 1.     -0.7071  0.      0.    ]
diff --git a/networkx/readwrite/json_graph/cytoscape.py b/networkx/readwrite/json_graph/cytoscape.py
index 306c4b4f418..8c45a020731 100644
--- a/networkx/readwrite/json_graph/cytoscape.py
+++ b/networkx/readwrite/json_graph/cytoscape.py
@@ -119,12 +119,16 @@ def cytoscape_graph(data, name="name", ident="id"):
     Examples
     --------
     >>> data_dict = {
-    ...     'data': [],
-    ...     'directed': False,
-    ...     'multigraph': False,
-    ...     'elements': {'nodes': [{'data': {'id': '0', 'value': 0, 'name': '0'}},
-    ...       {'data': {'id': '1', 'value': 1, 'name': '1'}}],
-    ...      'edges': [{'data': {'source': 0, 'target': 1}}]}
+    ...     "data": [],
+    ...     "directed": False,
+    ...     "multigraph": False,
+    ...     "elements": {
+    ...         "nodes": [
+    ...             {"data": {"id": "0", "value": 0, "name": "0"}},
+    ...             {"data": {"id": "1", "value": 1, "name": "1"}},
+    ...         ],
+    ...         "edges": [{"data": {"source": 0, "target": 1}}],
+    ...     },
     ... }
     >>> G = nx.cytoscape_graph(data_dict)
     >>> G.name
diff --git a/networkx/readwrite/json_graph/node_link.py b/networkx/readwrite/json_graph/node_link.py
index a9fbb29b2ad..e5136bad095 100644
--- a/networkx/readwrite/json_graph/node_link.py
+++ b/networkx/readwrite/json_graph/node_link.py
@@ -179,7 +179,7 @@ def node_link_graph(
 
     Create data in node-link format by converting a graph.
 
-    >>> G = nx.Graph([('A', 'B')])
+    >>> G = nx.Graph([("A", "B")])
     >>> data = nx.node_link_data(G)
     >>> data
     {'directed': False, 'multigraph': False, 'graph': {}, 'nodes': [{'id': 'A'}, {'id': 'B'}], 'links': [{'source': 'A', 'target': 'B'}]}
diff --git a/networkx/readwrite/text.py b/networkx/readwrite/text.py
index ba97011ffcd..dc182f59866 100644
--- a/networkx/readwrite/text.py
+++ b/networkx/readwrite/text.py
@@ -157,16 +157,16 @@ def generate_network_text(
     Examples
     --------
     >>> graph = nx.path_graph(10)
-    >>> graph.add_node('A')
-    >>> graph.add_node('B')
-    >>> graph.add_node('C')
-    >>> graph.add_node('D')
-    >>> graph.add_edge(9, 'A')
-    >>> graph.add_edge(9, 'B')
-    >>> graph.add_edge(9, 'C')
-    >>> graph.add_edge('C', 'D')
-    >>> graph.add_edge('C', 'E')
-    >>> graph.add_edge('C', 'F')
+    >>> graph.add_node("A")
+    >>> graph.add_node("B")
+    >>> graph.add_node("C")
+    >>> graph.add_node("D")
+    >>> graph.add_edge(9, "A")
+    >>> graph.add_edge(9, "B")
+    >>> graph.add_edge(9, "C")
+    >>> graph.add_edge("C", "D")
+    >>> graph.add_edge("C", "E")
+    >>> graph.add_edge("C", "F")
     >>> nx.write_network_text(graph)
     ╙── 0
         └── 1
diff --git a/networkx/relabel.py b/networkx/relabel.py
index 93a404921f9..6e5f805d9ba 100644
--- a/networkx/relabel.py
+++ b/networkx/relabel.py
@@ -65,7 +65,7 @@ def relabel_nodes(G, mapping, copy=True):
     A mapping can also be given as a function:
 
     >>> G = nx.path_graph(3)
-    >>> H = nx.relabel_nodes(G, lambda x: x ** 2)
+    >>> H = nx.relabel_nodes(G, lambda x: x**2)
     >>> list(H)
     [0, 1, 4]
 
diff --git a/networkx/utils/decorators.py b/networkx/utils/decorators.py
index dfb39b40f34..e986434bd43 100644
--- a/networkx/utils/decorators.py
+++ b/networkx/utils/decorators.py
@@ -57,11 +57,13 @@ def not_implemented_for(*graph_types):
        def sp_function(G):
            pass
 
+
        # rule out MultiDiGraph
-       @not_implemented_for("directed","multigraph")
+       @not_implemented_for("directed", "multigraph")
        def sp_np_function(G):
            pass
 
+
        # rule out all except DiGraph
        @not_implemented_for("undirected")
        @not_implemented_for("multigraph")
@@ -124,22 +126,26 @@ def open_file(path_arg, mode="r"):
     --------
     Decorate functions like this::
 
-       @open_file(0,"r")
+       @open_file(0, "r")
        def read_function(pathname):
            pass
 
-       @open_file(1,"w")
+
+       @open_file(1, "w")
        def write_function(G, pathname):
            pass
 
-       @open_file(1,"w")
+
+       @open_file(1, "w")
        def write_function(G, pathname="graph.dot"):
            pass
 
-       @open_file("pathname","w")
+
+       @open_file("pathname", "w")
        def write_function(G, pathname="graph.dot"):
            pass
 
+
        @open_file("path", "w+")
        def another_function(arg, **kwargs):
            path = kwargs["path"]
@@ -155,19 +161,19 @@ def another_function(arg, **kwargs):
 
       @open_file("path")
       def some_function(arg1, arg2, path=None):
-         if path is None:
-             fobj = tempfile.NamedTemporaryFile(delete=False)
-         else:
-             # `path` could have been a string or file object or something
-             # similar. In any event, the decorator has given us a file object
-             # and it will close it for us, if it should.
-             fobj = path
-
-         try:
-             fobj.write("blah")
-         finally:
-             if path is None:
-                 fobj.close()
+          if path is None:
+              fobj = tempfile.NamedTemporaryFile(delete=False)
+          else:
+              # `path` could have been a string or file object or something
+              # similar. In any event, the decorator has given us a file object
+              # and it will close it for us, if it should.
+              fobj = path
+
+          try:
+              fobj.write("blah")
+          finally:
+              if path is None:
+                  fobj.close()
 
     Normally, we'd want to use "with" to ensure that fobj gets closed.
     However, the decorator will make `path` a file object for us,
@@ -289,10 +295,12 @@ def np_random_state(random_state_argument):
        def random_float(seed=None):
            return seed.rand()
 
+
        @np_random_state(0)
        def random_float(rng=None):
            return rng.rand()
 
+
        @np_random_state(1)
        def random_array(dims, random_state=1):
            return random_state.rand(*dims)
@@ -341,10 +349,12 @@ def py_random_state(random_state_argument):
        def random_float(random_state=None):
            return random_state.rand()
 
+
        @py_random_state(0)
        def random_float(rng=None):
            return rng.rand()
 
+
        @py_random_state(1)
        def random_array(dims, seed=12345):
            return seed.rand(*dims)
@@ -414,6 +424,7 @@ def _convert(amount):
                 if amount.currency != currency:
                     amount = amount.to_currency(currency)
                 return amount
+
             return argmap(_convert, which_arg)
 
     Despite this common idiom for argmap, most of the following examples
@@ -473,10 +484,12 @@ def foo(a, b, c):
         def double(a):
             return 2 * a
 
+
         @argmap(double, 3)
         def overflow(a, *args):
             return a, args
 
+
         print(overflow(1, 2, 3, 4, 5, 6))  # output is 1, (2, 3, 8, 5, 6)
 
     **Try Finally**
@@ -526,6 +539,7 @@ def _opener(path):
                     # assume `path` handles the closing
                     fclose = lambda: None
                 return path, fclose
+
             return argmap(_opener, which_arg, try_finally=True)
 
     which can then be used as::
@@ -549,6 +563,7 @@ def file_to_lines_wrapped(file):
             for line in file.readlines():
                 yield line
 
+
         def file_to_lines_wrapper(file):
             try:
                 file = open_file(file)
diff --git a/networkx/utils/mapped_queue.py b/networkx/utils/mapped_queue.py
index 5dd85907645..afb97404cbe 100644
--- a/networkx/utils/mapped_queue.py
+++ b/networkx/utils/mapped_queue.py
@@ -114,11 +114,11 @@ class MappedQueue:
     of initial elements and priorities.  The methods `push`, `pop`,
     `remove`, and `update` operate on the queue.
 
-    >>> colors_nm = {'red':665, 'blue': 470, 'green': 550}
+    >>> colors_nm = {"red": 665, "blue": 470, "green": 550}
     >>> q = MappedQueue(colors_nm)
-    >>> q.remove('red')
-    >>> q.update('green', 'violet', 400)
-    >>> q.push('indigo', 425)
+    >>> q.remove("red")
+    >>> q.update("green", "violet", 400)
+    >>> q.push("indigo", 425)
     True
     >>> [q.pop().element for i in range(len(q.heap))]
     ['violet', 'indigo', 'blue']
@@ -134,14 +134,14 @@ class MappedQueue:
 
     An exception is raised if the elements are not comparable.
 
-    >>> q = MappedQueue([100, 'a'])
+    >>> q = MappedQueue([100, "a"])
     Traceback (most recent call last):
     ...
     TypeError: '<' not supported between instances of 'int' and 'str'
 
     To avoid the exception, use a dictionary to assign priorities to the elements.
 
-    >>> q = MappedQueue({100: 0, 'a': 1 })
+    >>> q = MappedQueue({100: 0, "a": 1})
 
     References
     ----------
diff --git a/networkx/utils/misc.py b/networkx/utils/misc.py
index 4cca68a4fb6..54b9b17dcd6 100644
--- a/networkx/utils/misc.py
+++ b/networkx/utils/misc.py
@@ -175,7 +175,7 @@ def arbitrary_element(iterable):
     >>> d = {k: v for k, v in zip([1, 2, 3], [3, 2, 1])}
     >>> nx.utils.arbitrary_element(d)  # dict_keys
     1
-    >>> nx.utils.arbitrary_element(d.values())   # dict values
+    >>> nx.utils.arbitrary_element(d.values())  # dict values
     3
 
     `str` is also an Iterable:
diff --git a/pyproject.toml b/pyproject.toml
index 078f4ae10bc..dd6abc72cee 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -192,6 +192,9 @@ select = [
 "tools/*.py" = ['I']
 "networkx/classes/filters.py" = ['C416']
 
+[tool.ruff.format]
+docstring-code-format = true
+
 [tool.mypy]
 ignore_missing_imports = true
 exclude = 'subgraphviews|reportviews'

From 1e6bcf6689a055ae6e8b22fbfa24b1323505f154 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Sat, 10 Feb 2024 02:15:26 -0800
Subject: [PATCH 067/129] Add docstring formatting change to blame-ignore-revs.
 (#7281)

---
 .git-blame-ignore-revs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
index 64b36ad820c..0dd46935381 100644
--- a/.git-blame-ignore-revs
+++ b/.git-blame-ignore-revs
@@ -12,3 +12,4 @@ be23fa0e422b51f4526828cb19b8105c89e5dcbb
 5c0b11afb4c0882a070d522ef3fa41482ba935d3
 5fcf01b9a43a097c4f579486023d1279b2b88619
 7297ae8a37dd3356b64d383cb0c55735a6364bcc
+3c0f096f66ab352cfaf8dbe2d5fc5731cbbc4338

From 74ce63f222df0189c1c9ae425b5b7748111d17f9 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Sun, 11 Feb 2024 21:51:26 -0800
Subject: [PATCH 068/129] Fix all sphinx warnings during doc build. (#7289)

---
 examples/3d_drawing/plot_3d_rotation_animation.py | 2 +-
 networkx/algorithms/operators/product.py          | 8 ++++----
 networkx/generators/nonisomorphic_trees.py        | 5 ++---
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/examples/3d_drawing/plot_3d_rotation_animation.py b/examples/3d_drawing/plot_3d_rotation_animation.py
index 2849b378f0a..9382fd5bf1f 100644
--- a/examples/3d_drawing/plot_3d_rotation_animation.py
+++ b/examples/3d_drawing/plot_3d_rotation_animation.py
@@ -1,6 +1,6 @@
 """
 =========================================
-Animations of 3D rotation and random walk.
+Animations of 3D rotation and random walk
 =========================================
 Examples of 3D plots of a graph in the 3D spectral layout with animation. 
 Following 
diff --git a/networkx/algorithms/operators/product.py b/networkx/algorithms/operators/product.py
index ee38fd7a18c..f7f1a4794f6 100644
--- a/networkx/algorithms/operators/product.py
+++ b/networkx/algorithms/operators/product.py
@@ -546,11 +546,11 @@ def modular_product(G, H):
     - if u is adjacent to x in `G` and v is adjacent to y in `H`, or
     - if u is not adjacent to x in `G` and v is not adjacent to y in `H`.
 
-    More formally
-    ::
+    More formally::
 
         E(M) = {((u, v), (x, y)) | ((u, x) in E(G) and (v, y) in E(H)) or
                                    ((u, x) not in E(G) and (v, y) not in E(H))}
+
     Parameters
     ----------
     G, H: NetworkX graphs
@@ -559,12 +559,12 @@ def modular_product(G, H):
     Returns
     -------
     M: NetworkX graph
-        The Modular product of G and H.
+        The Modular product of `G` and `H`.
 
     Raises
     ------
     NetworkXNotImplemented
-        If G is not a simple graph.
+        If `G` is not a simple graph.
 
     Examples
     --------
diff --git a/networkx/generators/nonisomorphic_trees.py b/networkx/generators/nonisomorphic_trees.py
index 4389e810a22..fbfcbd22e92 100644
--- a/networkx/generators/nonisomorphic_trees.py
+++ b/networkx/generators/nonisomorphic_trees.py
@@ -14,7 +14,7 @@
 
 @nx._dispatchable(graphs=None)
 def nonisomorphic_trees(order, create="graph"):
-    """Returns a list of nonisomorphic trees
+    """Generates lists of nonisomorphic trees
 
     Parameters
     ----------
@@ -31,8 +31,7 @@ def nonisomorphic_trees(order, create="graph"):
        A list of nonisomorphic trees, in one of two formats depending on the
        value of the `create` parameter:
        - ``create="graph"``: yields a list of `networkx.Graph` instances
-       - ``create="matrix"``: yields a list of list-of-lists representing
-         adjacency matrices
+       - ``create="matrix"``: yields a list of list-of-lists representing adjacency matrices
     """
 
     if order < 2:

From c85555728e6d31ed383375f7d03255ed23a02f4d Mon Sep 17 00:00:00 2001
From: Vanshika Mishra <74042272+vanshika230@users.noreply.github.com>
Date: Wed, 14 Feb 2024 13:26:08 +0530
Subject: [PATCH 069/129] Improve test coverage for random_clustered and update
 function names (#7273)

* Improve test_cov for random_clustered

* Add match

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>

* Cleanup invalid joint deg seq tests.

---------

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 .../generators/tests/test_random_clustered.py | 37 +++++++++----------
 1 file changed, 18 insertions(+), 19 deletions(-)

diff --git a/networkx/generators/tests/test_random_clustered.py b/networkx/generators/tests/test_random_clustered.py
index e3a37b6add6..85066520ae5 100644
--- a/networkx/generators/tests/test_random_clustered.py
+++ b/networkx/generators/tests/test_random_clustered.py
@@ -1,34 +1,33 @@
 import pytest
 
-import networkx
+import networkx as nx
 
 
 class TestRandomClusteredGraph:
-    def test_valid(self):
+    def test_custom_joint_degree_sequence(self):
         node = [1, 1, 1, 2, 1, 2, 0, 0]
         tri = [0, 0, 0, 0, 0, 1, 1, 1]
         joint_degree_sequence = zip(node, tri)
-        G = networkx.random_clustered_graph(joint_degree_sequence)
+        G = nx.random_clustered_graph(joint_degree_sequence)
         assert G.number_of_nodes() == 8
         assert G.number_of_edges() == 7
 
-    def test_valid2(self):
-        G = networkx.random_clustered_graph(
-            [(1, 2), (2, 1), (1, 1), (1, 1), (1, 1), (2, 0)]
-        )
+    def test_tuple_joint_degree_sequence(self):
+        G = nx.random_clustered_graph([(1, 2), (2, 1), (1, 1), (1, 1), (1, 1), (2, 0)])
         assert G.number_of_nodes() == 6
         assert G.number_of_edges() == 10
 
-    def test_invalid1(self):
-        pytest.raises(
-            (TypeError, networkx.NetworkXError),
-            networkx.random_clustered_graph,
-            [[1, 1], [2, 1], [0, 1]],
-        )
+    def test_invalid_joint_degree_sequence_type(self):
+        with pytest.raises(nx.NetworkXError, match="Invalid degree sequence"):
+            nx.random_clustered_graph([[1, 1], [2, 1], [0, 1]])
 
-    def test_invalid2(self):
-        pytest.raises(
-            (TypeError, networkx.NetworkXError),
-            networkx.random_clustered_graph,
-            [[1, 1], [1, 2], [0, 1]],
-        )
+    def test_invalid_joint_degree_sequence_value(self):
+        with pytest.raises(nx.NetworkXError, match="Invalid degree sequence"):
+            nx.random_clustered_graph([[1, 1], [1, 2], [0, 1]])
+
+    def test_directed_graph_raises_error(self):
+        with pytest.raises(nx.NetworkXError, match="Directed Graph not supported"):
+            nx.random_clustered_graph(
+                [(1, 2), (2, 1), (1, 1), (1, 1), (1, 1), (2, 0)],
+                create_using=nx.DiGraph,
+            )

From 5872457bf3f40503502e1ed74c8ab8d4e6ce7f55 Mon Sep 17 00:00:00 2001
From: Jon Crall <erotemic@gmail.com>
Date: Wed, 14 Feb 2024 12:06:08 -0500
Subject: [PATCH 070/129] Fix minimum_spanning_arborescence regression (#7280)

* Fix minimum_spanning_arborescence regression

* Add test for issue #7279

* Consolidate default-weight test into single function

* Fix default weight in minimum_branching
---
 networkx/algorithms/tree/branchings.py        | 28 +++++++++----------
 .../algorithms/tree/tests/test_branchings.py  | 26 +++++++++++++++++
 2 files changed, 39 insertions(+), 15 deletions(-)

diff --git a/networkx/algorithms/tree/branchings.py b/networkx/algorithms/tree/branchings.py
index eebc99a751b..e6c84051d8b 100644
--- a/networkx/algorithms/tree/branchings.py
+++ b/networkx/algorithms/tree/branchings.py
@@ -28,7 +28,6 @@
 # }
 import string
 from dataclasses import dataclass, field
-from enum import Enum
 from operator import itemgetter
 from queue import PriorityQueue
 
@@ -470,7 +469,6 @@ def find_optimum(
         D = set()
         nodes = iter(list(G.nodes()))
         attr = self._attr
-        G_pred = G.pred
 
         def desired_edge(v):
             """
@@ -1181,15 +1179,15 @@ def minimum_branching(
     G, attr="weight", default=1, preserve_attrs=False, partition=None
 ):
     for _, _, d in G.edges(data=True):
-        d[attr] = -d[attr]
+        d[attr] = -d.get(attr, default)
 
     B = maximum_branching(G, attr, default, preserve_attrs, partition)
 
     for _, _, d in G.edges(data=True):
-        d[attr] = -d[attr]
+        d[attr] = -d.get(attr, default)
 
     for _, _, d in B.edges(data=True):
-        d[attr] = -d[attr]
+        d[attr] = -d.get(attr, default)
 
     return B
 
@@ -1233,7 +1231,7 @@ def minimal_branching(
     """
     max_weight = -INF
     min_weight = INF
-    for _, _, w in G.edges(data=attr):
+    for _, _, w in G.edges(data=attr, default=default):
         if w > max_weight:
             max_weight = w
         if w < min_weight:
@@ -1244,16 +1242,16 @@ def minimal_branching(
         # the difference between the max and min weights. This is important
         # in order to prevent the edge weights from becoming negative during
         # computation
-        d[attr] = max_weight + 1 + (max_weight - min_weight) - d[attr]
+        d[attr] = max_weight + 1 + (max_weight - min_weight) - d.get(attr, default)
 
     B = maximum_branching(G, attr, default, preserve_attrs, partition)
 
     # Reverse the weight transformations
     for _, _, d in G.edges(data=True):
-        d[attr] = max_weight + 1 + (max_weight - min_weight) - d[attr]
+        d[attr] = max_weight + 1 + (max_weight - min_weight) - d.get(attr, default)
 
     for _, _, d in B.edges(data=True):
-        d[attr] = max_weight + 1 + (max_weight - min_weight) - d[attr]
+        d[attr] = max_weight + 1 + (max_weight - min_weight) - d.get(attr, default)
 
     return B
 
@@ -1277,22 +1275,22 @@ def maximum_spanning_arborescence(
 
     min_weight = INF
     max_weight = -INF
-    for _, _, w in G.edges(data=attr):
+    for _, _, w in G.edges(data=attr, default=default):
         if w < min_weight:
             min_weight = w
         if w > max_weight:
             max_weight = w
 
     for _, _, d in G.edges(data=True):
-        d[attr] = d[attr] - min_weight + 1 - (min_weight - max_weight)
+        d[attr] = d.get(attr, default) - min_weight + 1 - (min_weight - max_weight)
 
     B = maximum_branching(G, attr, default, preserve_attrs, partition)
 
     for _, _, d in G.edges(data=True):
-        d[attr] = d[attr] + min_weight - 1 + (min_weight - max_weight)
+        d[attr] = d.get(attr, default) + min_weight - 1 + (min_weight - max_weight)
 
     for _, _, d in B.edges(data=True):
-        d[attr] = d[attr] + min_weight - 1 + (min_weight - max_weight)
+        d[attr] = d.get(attr, default) + min_weight - 1 + (min_weight - max_weight)
 
     if not is_arborescence(B):
         raise nx.exception.NetworkXException("No maximum spanning arborescence in G.")
@@ -1365,8 +1363,8 @@ def minimum_spanning_arborescence(
 minimum_branching.__doc__ = (
     docstring_branching.format(kind="minimum", style="branching")
     + """
-See Also 
--------- 
+See Also
+--------
     minimal_branching
 """
 )
diff --git a/networkx/algorithms/tree/tests/test_branchings.py b/networkx/algorithms/tree/tests/test_branchings.py
index ad1cc33b9a4..9058606714f 100644
--- a/networkx/algorithms/tree/tests/test_branchings.py
+++ b/networkx/algorithms/tree/tests/test_branchings.py
@@ -630,3 +630,29 @@ def test_arborescence_iterator_initial_partition():
         for e in excluded_edges:
             assert e not in B.edges
     assert arborescence_count == 16
+
+
+def test_branchings_with_default_weights():
+    """
+    Tests that various brancing algorithms work on graphs without weights.
+    For more information, see issue #7279.
+    """
+    graph = nx.erdos_renyi_graph(10, p=0.2, directed=True, seed=123)
+
+    assert all(
+        "weight" not in d for (u, v, d) in graph.edges(data=True)
+    ), "test is for graphs without a weight attribute"
+
+    # Calling these functions will modify graph inplace to add weights
+    # copy the graph to avoid this.
+    nx.minimum_spanning_arborescence(graph.copy())
+    nx.maximum_spanning_arborescence(graph.copy())
+    nx.minimum_branching(graph.copy())
+    nx.maximum_branching(graph.copy())
+    nx.algorithms.tree.minimal_branching(graph.copy())
+    nx.algorithms.tree.branching_weight(graph.copy())
+    nx.algorithms.tree.greedy_branching(graph.copy())
+
+    assert all(
+        "weight" not in d for (u, v, d) in graph.edges(data=True)
+    ), "The above calls should not modify the initial graph in-place"

From eba1a4eec5a67a5b6d34d2d8a866d9a863028cc4 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Wed, 14 Feb 2024 10:42:41 -0800
Subject: [PATCH 071/129] Doc infrastructure: replace `nb2plot` with `myst-nb`
 (#7237)

* Update configuration and dependencies.

Co-authored-by: Dan Schult <dschult@colgate.edu>

* Rename tutorial rst -> md

File rename to preserve git blame: git mv tutorial.rst tutorial.md

* WIP: Convert to myst with rst2myst.

This commit encompasses the following cmds::

  mv tutorial.md tutorial.rst
  rst2myst convert tutorial.rst
  git commit  # the resulting changes to tutorial.md

* Manual tweaks to autogenned myst -> executable myst notebook

 * Replace ::: with ```
 * Replace ```{eval-rst}\n.. nbplot with ```{code-cell}
 * Rm blank lines, prompts (>>>), elipses (...) and outputs from cells
 * Add jupytext header to interpret as notebook
 * Fix a few broken links that the auto-converter messed up
 * Rm code-links directive

* Rename introduction rst -> md.

* WIP: Convert introduction with rst2myst.

This commit encompasses the following cmds::

  mv introduction.md introduction.rst
  rst2myst converter introduction.rst
  git commit  # the resulting changes to introduction.md

* Manual tweaks to autogenned myst->nb introduction

 * Replace ```{eval-rst}\n.. nbplot\n with ```{code-cell}
 * Rm prompts (>>>), ellipses (...) and outputs from cells
 * Add jupytext header
 * Fix a few broken links
 * A couple other markup formatting tweaks

* Switch randomness article to non-executable directives.

* Lint with pre-commit.

---------

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 doc/conf.py                    |  10 +-
 doc/reference/introduction.md  | 342 +++++++++++++++++
 doc/reference/introduction.rst | 344 -----------------
 doc/reference/randomness.rst   |   4 +-
 doc/tutorial.md                | 658 +++++++++++++++++++++++++++++++++
 doc/tutorial.rst               | 635 -------------------------------
 pyproject.toml                 |   2 +-
 requirements/doc.txt           |   2 +-
 8 files changed, 1011 insertions(+), 986 deletions(-)
 create mode 100644 doc/reference/introduction.md
 delete mode 100644 doc/reference/introduction.rst
 create mode 100644 doc/tutorial.md
 delete mode 100644 doc/tutorial.rst

diff --git a/doc/conf.py b/doc/conf.py
index f54a0228992..e2eb2a547c9 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -22,10 +22,10 @@
     "sphinx.ext.todo",
     "sphinx.ext.viewcode",
     "sphinx_gallery.gen_gallery",
-    "nb2plots",
     "texext",
     "numpydoc",
     "matplotlib.sphinxext.plot_directive",
+    "myst_nb",
 ]
 
 # https://github.com/sphinx-gallery/sphinx-gallery
@@ -77,8 +77,9 @@
 # The encoding of source files.
 source_encoding = "utf-8"
 
-# Do not include release announcement template
-exclude_patterns = ["release/release_template.rst"]
+# Items to exclude during source collection, including release announcement
+# template, build outputs, and READMEs (markdown only)
+exclude_patterns = ["release/release_template.rst", "build/*", "README.md"]
 
 # General substitutions.
 project = "NetworkX"
@@ -258,6 +259,9 @@
 def setup(app):
     app.add_css_file("custom.css")
     app.add_js_file("copybutton.js")
+    # Workaround to prevent duplicate file warnings from sphinx w/ myst-nb.
+    # See executablebooks/MyST-NB#363
+    app.registry.source_suffix.pop(".ipynb")
 
 
 # Monkeypatch numpydoc to show "Backends" section
diff --git a/doc/reference/introduction.md b/doc/reference/introduction.md
new file mode 100644
index 00000000000..a00cfe52c9b
--- /dev/null
+++ b/doc/reference/introduction.md
@@ -0,0 +1,342 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.13.1
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Introduction
+
+```{currentmodule} networkx
+
+```
+
+The structure of NetworkX can be seen by the organization of its source code.
+The package provides classes for graph objects, generators to create standard
+graphs, IO routines for reading in existing datasets, algorithms to analyze
+the resulting networks and some basic drawing tools.
+
+Most of the NetworkX API is provided by functions which take a graph object
+as an argument. Methods of the graph object are limited to basic manipulation
+and reporting. This provides modularity of code and documentation.
+It also makes it easier for newcomers to learn about the package in stages.
+The source code for each module is meant to be easy to read and reading
+this Python code is actually a good way to learn more about network algorithms,
+but we have put a lot of effort into making the documentation sufficient and friendly.
+If you have suggestions or questions please contact us by joining the
+[NetworkX Google group](http://groups.google.com/group/networkx-discuss).
+
+Classes are named using `CamelCase` (capital letters at the start of each word).
+functions, methods and variable names are `lower_case_underscore` (lowercase with
+an underscore representing a space between words).
+
+## NetworkX Basics
+
+After starting Python, import the networkx module with (the recommended way)
+
+```{code-cell}
+import networkx as nx
+```
+
+To save repetition, in the documentation we assume that
+NetworkX has been imported this way.
+
+If importing networkx fails, it means that Python cannot find the installed
+module. Check your installation and your `PYTHONPATH`.
+
+The following basic graph types are provided as Python classes:
+
+{class}`Graph`
+
+- This class implements an undirected graph. It ignores
+  multiple edges between two nodes. It does allow self-loop
+  edges between a node and itself.
+
+{class}`DiGraph`
+
+- Directed graphs, that is, graphs with directed edges.
+  Provides operations common to directed graphs,
+  (a subclass of Graph).
+
+{class}`MultiGraph`
+
+- A flexible graph class that allows multiple undirected edges between
+  pairs of nodes. The additional flexibility leads to some degradation
+  in performance, though usually not significant.
+
+{class}`MultiDiGraph`
+
+- A directed version of a MultiGraph.
+
+Empty graph-like objects are created with
+
+```{code-cell}
+G = nx.Graph()
+G = nx.DiGraph()
+G = nx.MultiGraph()
+G = nx.MultiDiGraph()
+```
+
+All graph classes allow any {term}`hashable` object as a node.
+Hashable objects include strings, tuples, integers, and more.
+Arbitrary edge attributes such as weights and labels
+can be associated with an edge.
+
+The graph internal data structures are based on an
+adjacency list representation and implemented using
+Python {term}`dictionary` datastructures.
+The graph adjacency structure is
+implemented as a Python dictionary of
+dictionaries; the outer dictionary is keyed by nodes to values that are
+themselves dictionaries keyed by neighboring node to the
+edge attributes associated with that edge. This "dict-of-dicts" structure
+allows fast addition, deletion, and lookup of nodes and neighbors in
+large graphs. The underlying datastructure is accessed directly
+by methods (the programming interface "API") in the class definitions.
+All functions, on the other hand, manipulate graph-like objects
+solely via those API methods and not by acting directly on the datastructure.
+This design allows for possible replacement of the 'dicts-of-dicts'-based
+datastructure with an alternative datastructure that implements the
+same methods.
+
+## Graphs
+
+The first choice to be made when using NetworkX is what type of graph
+object to use. A graph (network) is a collection of nodes together
+with a collection of edges that are pairs of nodes. Attributes are
+often associated with nodes and/or edges. NetworkX graph objects come in
+different flavors depending on two main properties of the network:
+
+> - Directed: Are the edges **directed**? Does the order of the edge
+>   pairs \$(u, v)\$ matter? A directed graph is specified by the "Di"
+>   prefix in the class name, e.g. {class}`DiGraph`. We make this distinction
+>   because many classical graph properties are defined differently for
+>   directed graphs.
+> - Multi-edges: Are multiple edges allowed between each pair of nodes?
+>   As you might imagine, multiple edges requires a different data
+>   structure, though clever users could design edge data attributes to
+>   support this functionality. We provide a standard data structure
+>   and interface for this type of graph using the prefix "Multi",
+>   e.g., {class}`MultiGraph`.
+
+The basic graph classes are named:
+{doc}`Graph </reference/classes/graph>`,
+{doc}`DiGraph</reference/classes/digraph>`,
+{doc}`MultiGraph </reference/classes/multigraph>`, and
+{doc}`MultiDiGraph </reference/classes/multidigraph>`
+
+### Nodes and Edges
+
+The next choice you have to make when specifying a graph is what kinds
+of nodes and edges to use.
+
+If the topology of the network is all you
+care about then using integers or strings as the nodes makes sense and
+you need not worry about edge data. If you have a data structure
+already in place to describe nodes you can simply use that structure
+as your nodes provided it is {term}`hashable`. If it is not hashable you can
+use a unique identifier to represent the node and assign the data
+as a {term}`node attribute`.
+
+Edges often have data associated with them. Arbitrary data
+can be associated with edges as an {term}`edge attribute`.
+If the data is numeric and the intent is to represent
+a _weighted_ graph then use the 'weight' keyword for the attribute.
+Some of the graph algorithms, such as
+Dijkstra's shortest path algorithm, use this attribute
+name by default to get the weight for each edge.
+
+Attributes can be assigned to an edge by using keyword/value
+pairs when adding edges. You can use any keyword
+to name your attribute and can then query the edge
+data using that attribute keyword.
+
+Once you've decided how to encode the nodes and edges, and whether you have
+an undirected/directed graph with or without multiedges you are ready to build
+your network.
+
+## Graph Creation
+
+NetworkX graph objects can be created in one of three ways:
+
+- Graph generators---standard algorithms to create network topologies.
+- Importing data from preexisting (usually file) sources.
+- Adding edges and nodes explicitly.
+
+Explicit addition and removal of nodes/edges is the easiest to describe.
+Each graph object supplies methods to manipulate the graph. For example,
+
+```{code-cell}
+G = nx.Graph()
+G.add_edge(1, 2)  # default edge data=1
+G.add_edge(2, 3, weight=0.9)  # specify edge data
+```
+
+Edge attributes can be anything:
+
+```{code-cell}
+import math
+G.add_edge('y', 'x', function=math.cos)
+G.add_node(math.cos)  # any hashable can be a node
+```
+
+You can add many edges at one time:
+
+```{code-cell}
+elist = [(1, 2), (2, 3), (1, 4), (4, 2)]
+G.add_edges_from(elist)
+elist = [('a', 'b', 5.0), ('b', 'c', 3.0), ('a', 'c', 1.0), ('c', 'd', 7.3)]
+G.add_weighted_edges_from(elist)
+```
+
+See the {doc}`/tutorial` for more examples.
+
+Some basic graph operations such as union and intersection
+are described in the {ref}`operators module <operators>` documentation.
+
+Graph generators such as {func}`~generators.random_graphs.binomial_graph`
+and {func}`~generators.random_graphs.erdos_renyi_graph` are
+provided in the {ref}`graph generators <generators>` subpackage.
+
+For importing network data from formats such as GML, GraphML, edge list text files
+see the {ref}`reading and writing graphs <readwrite>` subpackage.
+
+## Graph Reporting
+
+Class views provide basic reporting of nodes, neighbors, edges and degree.
+These views provide iteration over the properties as well as membership
+queries and data attribute lookup. The views refer to the graph data structure
+so changes to the graph are reflected in the views. This is analogous to
+dictionary views in Python 3. If you want to change the graph while iterating
+you will need to use e.g. `for e in list(G.edges):`. The views provide
+set-like operations, e.g. union and intersection, as well as dict-like
+lookup and iteration of the data attributes using `G.edges[u, v]['color']`
+and `for e, datadict in G.edges.items():`. Methods `G.edges.items()` and
+`G.edges.values()` are familiar from python dicts. In addition `G.edges.data()`
+provides specific attribute iteration e.g. `for e, e_color in G.edges.data('color'):`.
+
+The basic graph relationship of an edge can be obtained in two ways.
+One can look for neighbors of a node or one can look for edges.
+We jokingly refer to people who focus on nodes/neighbors as node-centric
+and people who focus on edges as edge-centric. The designers of NetworkX
+tend to be node-centric and view edges as a relationship between nodes.
+You can see this by our choice of lookup notation like `G[u]` providing neighbors
+(adjacency) while edge lookup is `G.edges[u, v]`.
+Most data structures for sparse graphs are essentially adjacency lists and so
+fit this perspective. In the end, of course, it doesn't really matter which way
+you examine the graph. `G.edges` removes duplicate representations of undirected
+edges while neighbor reporting across all nodes will naturally report both directions.
+
+Any properties that are more complicated than edges, neighbors and degree are
+provided by functions. For example `nx.triangles(G, n)` gives the number of triangles
+which include node n as a vertex. These functions are grouped in the code and
+documentation under the term {ref}`algorithms<algorithms>`.
+
+## Algorithms
+
+A number of graph algorithms are provided with NetworkX.
+These include shortest path, and breadth first search
+(see {ref}`traversal<traversal>`),
+clustering and isomorphism algorithms and others. There are
+many that we have not developed yet too. If you implement a
+graph algorithm that might be useful for others please let
+us know through the
+[NetworkX Google group](http://groups.google.com/group/networkx-discuss)
+or the GitHub [Developer Zone](https://github.com/networkx/networkx).
+
+As an example here is code to use Dijkstra's algorithm to
+find the shortest weighted path:
+
+```{code-cell}
+G = nx.Graph()
+e = [('a', 'b', 0.3), ('b', 'c', 0.9), ('a', 'c', 0.5), ('c', 'd', 1.2)]
+G.add_weighted_edges_from(e)
+print(nx.dijkstra_path(G, 'a', 'd'))
+```
+
+## Drawing
+
+While NetworkX is not designed as a network drawing tool, we provide
+a simple interface to drawing packages and some simple layout algorithms.
+We interface to the excellent Graphviz layout tools like dot and neato
+with the (suggested) pygraphviz package or the pydot interface.
+Drawing can be done using external programs or the Matplotlib Python
+package. Interactive GUI interfaces are possible, though not provided.
+The drawing tools are provided in the module {ref}`drawing <drawing>`.
+
+The basic drawing functions essentially place the nodes on a scatterplot
+using the positions you provide via a dictionary or the positions are
+computed with a layout function. The edges are lines between those dots.
+
+```{code-cell}
+import matplotlib.pyplot as plt
+G = nx.cubical_graph()
+subax1 = plt.subplot(121)
+nx.draw(G)   # default spring_layout
+subax2 = plt.subplot(122)
+nx.draw(G, pos=nx.circular_layout(G), node_color='r', edge_color='b')
+```
+
+See the {doc}`examples </auto_examples/index>` for more ideas.
+
+## Data Structure
+
+NetworkX uses a "dictionary of dictionaries of dictionaries" as the
+basic network data structure. This allows fast lookup with reasonable
+storage for large sparse networks. The keys are nodes so `G[u]` returns
+an adjacency dictionary keyed by neighbor to the edge attribute
+dictionary. A view of the adjacency data structure is provided
+by the dict-like object `G.adj` as e.g. `for node, nbrsdict in G.adj.items():`.
+The expression `G[u][v]` returns the edge attribute dictionary itself.
+A dictionary of lists would have also been possible, but not allow
+fast edge detection nor convenient storage of edge data.
+
+Advantages of dict-of-dicts-of-dicts data structure:
+
+- Find edges and remove edges with two dictionary look-ups.
+- Prefer to "lists" because of fast lookup with sparse storage.
+- Prefer to "sets" since data can be attached to edge.
+- `G[u][v]` returns the edge attribute dictionary.
+- `n in G` tests if node `n` is in graph `G`.
+- `for n in G:` iterates through the graph.
+- `for nbr in G[n]:` iterates through neighbors.
+
+As an example, here is a representation of an undirected graph with the
+edges \$(A, B)\$ and \$(B, C)\$.
+
+```{code-cell}
+G = nx.Graph()
+G.add_edge('A', 'B')
+G.add_edge('B', 'C')
+print(G.adj)
+```
+
+The data structure gets morphed slightly for each base graph class.
+For DiGraph two dict-of-dicts-of-dicts structures are provided, one
+for successors (`G.succ`) and one for predecessors (`G.pred`).
+For MultiGraph/MultiDiGraph we use a dict-of-dicts-of-dicts-of-dicts [^turtles]
+where the third dictionary is keyed by an edge key identifier to the fourth
+dictionary which contains the edge attributes for that edge between
+the two nodes.
+
+Graphs provide two interfaces to the edge data attributes: adjacency
+and edges. So `G[u][v]['width']` is the same as `G.edges[u, v]['width']`.
+
+```{code-cell}
+G = nx.Graph()
+G.add_edge(1, 2, color='red', weight=0.84, size=300)
+print(G[1][2]['size'])
+print(G.edges[1, 2]['color'])
+```
+
+```{rubric} Footnotes
+
+```
+
+[^turtles]: "It's dictionaries all the way down."
diff --git a/doc/reference/introduction.rst b/doc/reference/introduction.rst
deleted file mode 100644
index 70fc3f5c758..00000000000
--- a/doc/reference/introduction.rst
+++ /dev/null
@@ -1,344 +0,0 @@
-Introduction
-============
-
-.. currentmodule:: networkx
-
-The structure of NetworkX can be seen by the organization of its source code.
-The package provides classes for graph objects, generators to create standard
-graphs, IO routines for reading in existing datasets, algorithms to analyze
-the resulting networks and some basic drawing tools.
-
-Most of the NetworkX API is provided by functions which take a graph object
-as an argument.  Methods of the graph object are limited to basic manipulation
-and reporting.  This provides modularity of code and documentation.
-It also makes it easier for newcomers to learn about the package in stages.
-The source code for each module is meant to be easy to read and reading
-this Python code is actually a good way to learn more about network algorithms,
-but we have put a lot of effort into making the documentation sufficient and friendly.
-If you have suggestions or questions please contact us by joining the
-`NetworkX Google group <http://groups.google.com/group/networkx-discuss>`_.
-
-Classes are named using ``CamelCase`` (capital letters at the start of each word).
-functions, methods and variable names are ``lower_case_underscore`` (lowercase with
-an underscore representing a space between words).
-
-
-NetworkX Basics
----------------
-
-After starting Python, import the networkx module with (the recommended way)
-
-.. nbplot::
-
-   >>> import networkx as nx
-
-To save repetition, in the documentation we assume that
-NetworkX has been imported this way.
-
-If importing networkx fails, it means that Python cannot find the installed
-module. Check your installation and your ``PYTHONPATH``.
-
-The following basic graph types are provided as Python classes:
-
-:class:`Graph`
-   This class implements an undirected graph. It ignores
-   multiple edges between two nodes.  It does allow self-loop
-   edges between a node and itself.
-
-:class:`DiGraph`
-   Directed graphs, that is, graphs with directed edges.
-   Provides operations common to directed graphs,
-   (a subclass of Graph).
-
-:class:`MultiGraph`
-   A flexible graph class that allows multiple undirected edges between
-   pairs of nodes.  The additional flexibility leads to some degradation
-   in performance, though usually not significant.
-
-:class:`MultiDiGraph`
-   A directed version of a MultiGraph.
-
-Empty graph-like objects are created with
-
-.. nbplot::
-
-   >>> G = nx.Graph()
-   >>> G = nx.DiGraph()
-   >>> G = nx.MultiGraph()
-   >>> G = nx.MultiDiGraph()
-
-All graph classes allow any :term:`hashable` object as a node.
-Hashable objects include strings, tuples, integers, and more.
-Arbitrary edge attributes such as weights and labels
-can be associated with an edge.
-
-
-The graph internal data structures are based on an
-adjacency list representation and implemented using
-Python :term:`dictionary` datastructures.
-The graph adjacency structure is
-implemented as a Python dictionary of
-dictionaries; the outer dictionary is keyed by nodes to values that are
-themselves dictionaries keyed by neighboring node to the
-edge attributes associated with that edge.  This "dict-of-dicts" structure
-allows fast addition, deletion, and lookup of nodes and neighbors in
-large graphs.  The underlying datastructure is accessed directly
-by methods (the programming interface "API") in the class definitions.
-All functions, on the other hand, manipulate graph-like objects
-solely via those API methods and not by acting directly on the datastructure.
-This design allows for possible replacement of the 'dicts-of-dicts'-based
-datastructure with an alternative datastructure that implements the
-same methods.
-
-
-Graphs
-------
-
-The first choice to be made when using NetworkX is what type of graph
-object to use.  A graph (network) is a collection of nodes together
-with a collection of edges that are pairs of nodes.  Attributes are
-often associated with nodes and/or edges.  NetworkX graph objects come in
-different flavors depending on two main properties of the network:
-
- - Directed: Are the edges **directed**?  Does the order of the edge
-   pairs $(u, v)$ matter?  A directed graph is specified by the "Di"
-   prefix in the class name, e.g. `DiGraph()`.  We make this distinction
-   because many classical graph properties are defined differently for
-   directed graphs.
-
- - Multi-edges: Are multiple edges allowed between each pair of nodes?
-   As you might imagine, multiple edges requires a different data
-   structure, though clever users could design edge data attributes to
-   support this functionality.  We provide a standard data structure
-   and interface for this type of graph using the prefix "Multi",
-   e.g., `MultiGraph()`.
-
-The basic graph classes are named:
-:doc:`Graph </reference/classes/graph>`,
-:doc:`DiGraph</reference/classes/digraph>`,
-:doc:`MultiGraph </reference/classes/multigraph>`, and
-:doc:`MultiDiGraph </reference/classes/multidigraph>`
-
-
-Nodes and Edges
-^^^^^^^^^^^^^^^
-
-The next choice you have to make when specifying a graph is what kinds
-of nodes and edges to use.
-
-If the topology of the network is all you
-care about then using integers or strings as the nodes makes sense and
-you need not worry about edge data.  If you have a data structure
-already in place to describe nodes you can simply use that structure
-as your nodes provided it is :term:`hashable`.  If it is not hashable you can
-use a unique identifier to represent the node and assign the data
-as a :term:`node attribute`.
-
-Edges often have data associated with them.  Arbitrary data
-can be associated with edges as an :term:`edge attribute`.
-If the data is numeric and the intent is to represent
-a *weighted* graph then use the 'weight' keyword for the attribute.
-Some of the graph algorithms, such as
-Dijkstra's shortest path algorithm, use this attribute
-name by default to get the weight for each edge.
-
-Attributes can be assigned to an edge by using keyword/value
-pairs when adding edges.  You can use any keyword
-to name your attribute and can then query the edge
-data using that attribute keyword.
-
-Once you've decided how to encode the nodes and edges, and whether you have
-an undirected/directed graph with or without multiedges you are ready to build
-your network.
-
-Graph Creation
---------------
-
-NetworkX graph objects can be created in one of three ways:
-
-- Graph generators---standard algorithms to create network topologies.
-- Importing data from preexisting (usually file) sources.
-- Adding edges and nodes explicitly.
-
-Explicit addition and removal of nodes/edges is the easiest to describe.
-Each graph object supplies methods to manipulate the graph.  For example,
-
-.. nbplot::
-
-   >>> import networkx as nx
-   >>> G = nx.Graph()
-   >>> G.add_edge(1, 2)  # default edge data=1
-   >>> G.add_edge(2, 3, weight=0.9)  # specify edge data
-
-Edge attributes can be anything:
-
-.. nbplot::
-
-   >>> import math
-   >>> G.add_edge('y', 'x', function=math.cos)
-   >>> G.add_node(math.cos)  # any hashable can be a node
-
-You can add many edges at one time:
-
-.. nbplot::
-
-   >>> elist = [(1, 2), (2, 3), (1, 4), (4, 2)]
-   >>> G.add_edges_from(elist)
-   >>> elist = [('a', 'b', 5.0), ('b', 'c', 3.0), ('a', 'c', 1.0), ('c', 'd', 7.3)]
-   >>> G.add_weighted_edges_from(elist)
-
-See the :doc:`/tutorial` for more examples.
-
-Some basic graph operations such as union and intersection
-are described in the :ref:`operators module <operators>` documentation.
-
-Graph generators such as :func:`~generators.random_graphs.binomial_graph`
-and :func:`~generators.random_graphs.erdos_renyi_graph` are
-provided in the :ref:`graph generators <generators>` subpackage.
-
-For importing network data from formats such as GML, GraphML, edge list text files
-see the :ref:`reading and writing graphs <readwrite>` subpackage.
-
-
-Graph Reporting
----------------
-
-Class views provide basic reporting of nodes, neighbors, edges and degree.
-These views provide iteration over the properties as well as membership
-queries and data attribute lookup. The views refer to the graph data structure
-so changes to the graph are reflected in the views. This is analogous to
-dictionary views in Python 3. If you want to change the graph while iterating
-you will need to use e.g. ``for e in list(G.edges):``. The views provide
-set-like operations, e.g. union and intersection, as well as dict-like
-lookup and iteration of the data attributes using ``G.edges[u, v]['color']``
-and ``for e, datadict in G.edges.items():``. Methods ``G.edges.items()`` and
-``G.edges.values()`` are familiar from python dicts. In addition ``G.edges.data()``
-provides specific attribute iteration e.g. ``for e, e_color in G.edges.data('color'):``.
-
-The basic graph relationship of an edge can be obtained in two ways.
-One can look for neighbors of a node or one can look for edges.
-We jokingly refer to people who focus on nodes/neighbors as node-centric
-and people who focus on edges as edge-centric.  The designers of NetworkX
-tend to be node-centric and view edges as a relationship between nodes.
-You can see this by our choice of lookup notation like ``G[u]`` providing neighbors
-(adjacency) while edge lookup is ``G.edges[u, v]``.
-Most data structures for sparse graphs are essentially adjacency lists and so
-fit this perspective. In the end, of course, it doesn't really matter which way
-you examine the graph. ``G.edges`` removes duplicate representations of undirected
-edges while neighbor reporting across all nodes will naturally report both directions.
-
-Any properties that are more complicated than edges, neighbors and degree are
-provided by functions.  For example ``nx.triangles(G, n)`` gives the number of triangles
-which include node n as a vertex.  These functions are grouped in the code and
-documentation under the term :ref:`algorithms<algorithms>`.
-
-
-Algorithms
-----------
-
-A number of graph algorithms are provided with NetworkX.
-These include shortest path, and breadth first search
-(see :ref:`traversal<traversal>`),
-clustering and isomorphism algorithms and others.  There are
-many that we have not developed yet too.  If you implement a
-graph algorithm that might be useful for others please let
-us know through the
-`NetworkX Google group <http://groups.google.com/group/networkx-discuss>`_
-or the GitHub `Developer Zone <https://github.com/networkx/networkx>`_.
-
-As an example here is code to use Dijkstra's algorithm to
-find the shortest weighted path:
-
-.. nbplot::
-
-   >>> G = nx.Graph()
-   >>> e = [('a', 'b', 0.3), ('b', 'c', 0.9), ('a', 'c', 0.5), ('c', 'd', 1.2)]
-   >>> G.add_weighted_edges_from(e)
-   >>> print(nx.dijkstra_path(G, 'a', 'd'))
-   ['a', 'c', 'd']
-
-Drawing
--------
-
-While NetworkX is not designed as a network drawing tool, we provide
-a simple interface to drawing packages and some simple layout algorithms.
-We interface to the excellent Graphviz layout tools like dot and neato
-with the (suggested) pygraphviz package or the pydot interface.
-Drawing can be done using external programs or the Matplotlib Python
-package.  Interactive GUI interfaces are possible, though not provided.
-The drawing tools are provided in the module :ref:`drawing <drawing>`.
-
-The basic drawing functions essentially place the nodes on a scatterplot
-using the positions you provide via a dictionary or the positions are
-computed with a layout function. The edges are lines between those dots.
-
-.. nbplot::
-
-   >>> import matplotlib.pyplot as plt
-   >>> G = nx.cubical_graph()
-   >>> subax1 = plt.subplot(121)
-   >>> nx.draw(G)   # default spring_layout
-   >>> subax2 = plt.subplot(122)
-   >>> nx.draw(G, pos=nx.circular_layout(G), node_color='r', edge_color='b')
-
-See the :doc:`examples </auto_examples/index>` for more ideas.
-
-Data Structure
---------------
-
-NetworkX uses a "dictionary of dictionaries of dictionaries" as the
-basic network data structure.  This allows fast lookup with reasonable
-storage for large sparse networks.  The keys are nodes so ``G[u]`` returns
-an adjacency dictionary keyed by neighbor to the edge attribute
-dictionary. A view of the adjacency data structure is provided
-by the dict-like object ``G.adj`` as e.g. ``for node, nbrsdict in G.adj.items():``.
-The expression ``G[u][v]`` returns the edge attribute dictionary itself.
-A dictionary of lists would have also been possible, but not allow
-fast edge detection nor convenient storage of edge data.
-
-Advantages of dict-of-dicts-of-dicts data structure:
-
- - Find edges and remove edges with two dictionary look-ups.
- - Prefer to "lists" because of fast lookup with sparse storage.
- - Prefer to "sets" since data can be attached to edge.
- - ``G[u][v]`` returns the edge attribute dictionary.
- - ``n in G`` tests if node ``n`` is in graph ``G``.
- - ``for n in G:`` iterates through the graph.
- - ``for nbr in G[n]:`` iterates through neighbors.
-
-As an example, here is a representation of an undirected graph with the
-edges $(A, B)$ and $(B, C)$.
-
-.. nbplot::
-
-   >>> G = nx.Graph()
-   >>> G.add_edge('A', 'B')
-   >>> G.add_edge('B', 'C')
-   >>> print(G.adj)
-   {'A': {'B': {}}, 'B': {'A': {}, 'C': {}}, 'C': {'B': {}}}
-
-The data structure gets morphed slightly for each base graph class.
-For DiGraph two dict-of-dicts-of-dicts structures are provided, one
-for successors (``G.succ``) and one for predecessors (``G.pred``).
-For MultiGraph/MultiDiGraph we use a dict-of-dicts-of-dicts-of-dicts [#turtles]_
-where the third dictionary is keyed by an edge key identifier to the fourth
-dictionary which contains the edge attributes for that edge between
-the two nodes.
-
-Graphs provide two interfaces to the edge data attributes: adjacency
-and edges. So ``G[u][v]['width']`` is the same as ``G.edges[u, v]['width']``.
-
-.. nbplot::
-
-   >>> G = nx.Graph()
-   >>> G.add_edge(1, 2, color='red', weight=0.84, size=300)
-   >>> print(G[1][2]['size'])
-   300
-   >>> print(G.edges[1, 2]['color'])
-   red
-
-.. code-links::
-
-.. rubric:: Footnotes
-
-.. [#turtles] "It's dictionaries all the way down."
diff --git a/doc/reference/randomness.rst b/doc/reference/randomness.rst
index 4ca72802583..dc9db60a994 100644
--- a/doc/reference/randomness.rst
+++ b/doc/reference/randomness.rst
@@ -27,7 +27,7 @@ RNGs, you may find yourself using another package that uses the other.
 Setting the state of the two global RNGs is as simple setting the
 seed of each RNG to an arbitrary integer:
 
-.. nbplot::
+.. code-block::
 
    >>> import random
    >>> random.seed(246)        # or any integer
@@ -41,7 +41,7 @@ to functions that use an RNG.  This argument is called `seed`, but
 determines more than the seed of the RNG. It tells the function which
 RNG package to use, and whether to use a global or local RNG.
 
-.. nbplot::
+.. code-block::
 
     >>> from networkx import path_graph, random_layout
     >>> G = path_graph(9)
diff --git a/doc/tutorial.md b/doc/tutorial.md
new file mode 100644
index 00000000000..f5ef8714187
--- /dev/null
+++ b/doc/tutorial.md
@@ -0,0 +1,658 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.13.1
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Tutorial
+
+```{currentmodule} networkx
+
+```
+
+This guide can help you start working with NetworkX.
+
+## Creating a graph
+
+Create an empty graph with no nodes and no edges.
+
+```{code-cell}
+import networkx as nx
+G = nx.Graph()
+```
+
+By definition, a {class}`Graph` is a collection of nodes (vertices) along with
+identified pairs of nodes (called edges, links, etc). In NetworkX, nodes can
+be any {py:term}`hashable` object e.g., a text string, an image, an XML object,
+another Graph, a customized node object, etc.
+
+```{note}
+Python's `None` object is not allowed to be used as a node. It
+determines whether optional function arguments have been assigned in many
+functions.
+```
+
+## Nodes
+
+The graph `G` can be grown in several ways. NetworkX includes many
+{doc}`graph generator functions <reference/generators>` and
+{doc}`facilities to read and write graphs in many formats <reference/readwrite/index>`.
+To get started though we'll look at simple manipulations. You can add one node
+at a time,
+
+```{code-cell}
+G.add_node(1)
+```
+
+or add nodes from any {py:term}`iterable` container, such as a list
+
+```{code-cell}
+G.add_nodes_from([2, 3])
+```
+
+You can also add nodes along with node
+attributes if your container yields 2-tuples of the form
+`(node, node_attribute_dict)`:
+
+```{code-cell}
+G.add_nodes_from([(4, {"color": "red"}), (5, {"color": "green"})])
+```
+
+Node attributes are discussed further {ref}`below <attributes>`.
+
+Nodes from one graph can be incorporated into another:
+
+```{code-cell}
+H = nx.path_graph(10)
+G.add_nodes_from(H)
+```
+
+`G` now contains the nodes of `H` as nodes of `G`.
+In contrast, you could use the graph `H` as a node in `G`.
+
+```{code-cell}
+G.add_node(H)
+```
+
+The graph `G` now contains `H` as a node. This flexibility is very powerful as
+it allows graphs of graphs, graphs of files, graphs of functions and much more.
+It is worth thinking about how to structure your application so that the nodes
+are useful entities. Of course you can always use a unique identifier in `G`
+and have a separate dictionary keyed by identifier to the node information if
+you prefer.
+
+```{note}
+You should not change the node object if the hash depends on its contents.
+```
+
+## Edges
+
+`G` can also be grown by adding one edge at a time,
+
+```{code-cell}
+G.add_edge(1, 2)
+e = (2, 3)
+G.add_edge(*e)  # unpack edge tuple*
+```
+
+by adding a list of edges,
+
+```{code-cell}
+G.add_edges_from([(1, 2), (1, 3)])
+```
+
+or by adding any {term}`ebunch` of edges. An _ebunch_ is any iterable
+container of edge-tuples. An edge-tuple can be a 2-tuple of nodes or a 3-tuple
+with 2 nodes followed by an edge attribute dictionary, e.g.,
+`(2, 3, {'weight': 3.1415})`. Edge attributes are discussed further
+{ref}`below <attributes>`.
+
+```{code-cell}
+G.add_edges_from(H.edges)
+```
+
+There are no complaints when adding existing nodes or edges. For example,
+after removing all nodes and edges,
+
+```{code-cell}
+G.clear()
+```
+
+we add new nodes/edges and NetworkX quietly ignores any that are
+already present.
+
+```{code-cell}
+G.add_edges_from([(1, 2), (1, 3)])
+G.add_node(1)
+G.add_edge(1, 2)
+G.add_node("spam")        # adds node "spam"
+G.add_nodes_from("spam")  # adds 4 nodes: 's', 'p', 'a', 'm'
+G.add_edge(3, 'm')
+```
+
+At this stage the graph `G` consists of 8 nodes and 3 edges, as can be seen by:
+
+```{code-cell}
+G.number_of_nodes()
+```
+
+```{code-cell}
+G.number_of_edges()
+```
+
+```{note}
+The order of adjacency reporting (e.g., {meth}`G.adj <networkx.Graph.adj>`,
+{meth}`G.successors <networkx.DiGraph.successors>`,
+{meth}`G.predecessors <networkx.DiGraph.predecessors>`) is the order of
+edge addition. However, the order of G.edges is the order of the adjacencies
+which includes both the order of the nodes and each
+node's adjacencies. See example below:
+```
+
+```{code-cell}
+DG = nx.DiGraph()
+DG.add_edge(2, 1)   # adds the nodes in order 2, 1
+DG.add_edge(1, 3)
+DG.add_edge(2, 4)
+DG.add_edge(1, 2)
+assert list(DG.successors(2)) == [1, 4]
+assert list(DG.edges) == [(2, 1), (2, 4), (1, 3), (1, 2)]
+```
+
+## Examining elements of a graph
+
+We can examine the nodes and edges. Four basic graph properties facilitate
+reporting: `G.nodes`, `G.edges`, `G.adj` and `G.degree`. These
+are set-like views of the nodes, edges, neighbors (adjacencies), and degrees
+of nodes in a graph. They offer a continually updated read-only view into
+the graph structure. They are also dict-like in that you can look up node
+and edge data attributes via the views and iterate with data attributes
+using methods `.items()`, `.data()`.
+If you want a specific container type instead of a view, you can specify one.
+Here we use lists, though sets, dicts, tuples and other containers may be
+better in other contexts.
+
+```{code-cell}
+list(G.nodes)
+```
+
+```{code-cell}
+list(G.edges)
+```
+
+```{code-cell}
+list(G.adj[1])  # or list(G.neighbors(1))
+```
+
+```{code-cell}
+G.degree[1]  # the number of edges incident to 1
+```
+
+One can specify to report the edges and degree from a subset of all nodes
+using an {term}`nbunch`. An _nbunch_ is any of: `None` (meaning all nodes),
+a node, or an iterable container of nodes that is not itself a node in the
+graph.
+
+```{code-cell}
+G.edges([2, 'm'])
+```
+
+```{code-cell}
+G.degree([2, 3])
+```
+
+## Removing elements from a graph
+
+One can remove nodes and edges from the graph in a similar fashion to adding.
+Use methods
+{meth}`Graph.remove_node`,
+{meth}`Graph.remove_nodes_from`,
+{meth}`Graph.remove_edge`
+and
+{meth}`Graph.remove_edges_from`, e.g.
+
+```{code-cell}
+G.remove_node(2)
+G.remove_nodes_from("spam")
+list(G.nodes)
+```
+
+```{code-cell}
+G.remove_edge(1, 3)
+list(G)
+```
+
+## Using the graph constructors
+
+Graph objects do not have to be built up incrementally - data specifying
+graph structure can be passed directly to the constructors of the various
+graph classes.
+When creating a graph structure by instantiating one of the graph
+classes you can specify data in several formats.
+
+```{code-cell}
+G.add_edge(1, 2)
+H = nx.DiGraph(G)  # create a DiGraph using the connections from G
+list(H.edges())
+```
+
+```{code-cell}
+edgelist = [(0, 1), (1, 2), (2, 3)]
+H = nx.Graph(edgelist)  # create a graph from an edge list
+list(H.edges())
+```
+
+```{code-cell}
+adjacency_dict = {0: (1, 2), 1: (0, 2), 2: (0, 1)}
+H = nx.Graph(adjacency_dict)  # create a Graph dict mapping nodes to nbrs
+list(H.edges())
+```
+
+## What to use as nodes and edges
+
+You might notice that nodes and edges are not specified as NetworkX
+objects. This leaves you free to use meaningful items as nodes and
+edges. The most common choices are numbers or strings, but a node can
+be any hashable object (except `None`), and an edge can be associated
+with any object `x` using `G.add_edge(n1, n2, object=x)`.
+
+As an example, `n1` and `n2` could be protein objects from the RCSB Protein
+Data Bank, and `x` could refer to an XML record of publications detailing
+experimental observations of their interaction.
+
+We have found this power quite useful, but its abuse
+can lead to surprising behavior unless one is familiar with Python.
+If in doubt, consider using {func}`~relabel.convert_node_labels_to_integers` to obtain
+a more traditional graph with integer labels.
+
+## Accessing edges and neighbors
+
+In addition to the views {attr}`Graph.edges`, and {attr}`Graph.adj`,
+access to edges and neighbors is possible using subscript notation.
+
+```{code-cell}
+G = nx.Graph([(1, 2, {"color": "yellow"})])
+G[1]  # same as G.adj[1]
+```
+
+```{code-cell}
+G[1][2]
+```
+
+```{code-cell}
+G.edges[1, 2]
+```
+
+You can get/set the attributes of an edge using subscript notation
+if the edge already exists.
+
+```{code-cell}
+G.add_edge(1, 3)
+G[1][3]['color'] = "blue"
+G.edges[1, 2]['color'] = "red"
+G.edges[1, 2]
+```
+
+Fast examination of all (node, adjacency) pairs is achieved using
+`G.adjacency()`, or `G.adj.items()`.
+Note that for undirected graphs, adjacency iteration sees each edge twice.
+
+```{code-cell}
+FG = nx.Graph()
+FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])
+for n, nbrs in FG.adj.items():
+   for nbr, eattr in nbrs.items():
+       wt = eattr['weight']
+       if wt < 0.5: print(f"({n}, {nbr}, {wt:.3})")
+```
+
+Convenient access to all edges is achieved with the edges property.
+
+```{code-cell}
+for (u, v, wt) in FG.edges.data('weight'):
+    if wt < 0.5:
+        print(f"({u}, {v}, {wt:.3})")
+```
+
+(attributes)=
+
+## Adding attributes to graphs, nodes, and edges
+
+Attributes such as weights, labels, colors, or whatever Python object you like,
+can be attached to graphs, nodes, or edges.
+
+Each graph, node, and edge can hold key/value attribute pairs in an associated
+attribute dictionary (the keys must be hashable). By default these are empty,
+but attributes can be added or changed using `add_edge`, `add_node` or direct
+manipulation of the attribute dictionaries named `G.graph`, `G.nodes`, and
+`G.edges` for a graph `G`.
+
+### Graph attributes
+
+Assign graph attributes when creating a new graph
+
+```{code-cell}
+G = nx.Graph(day="Friday")
+G.graph
+```
+
+Or you can modify attributes later
+
+```{code-cell}
+G.graph['day'] = "Monday"
+G.graph
+```
+
+### Node attributes
+
+Add node attributes using `add_node()`, `add_nodes_from()`, or `G.nodes`
+
+```{code-cell}
+G.add_node(1, time='5pm')
+G.add_nodes_from([3], time='2pm')
+G.nodes[1]
+```
+
+```{code-cell}
+G.nodes[1]['room'] = 714
+G.nodes.data()
+```
+
+Note that adding a node to `G.nodes` does not add it to the graph, use
+`G.add_node()` to add new nodes. Similarly for edges.
+
+### Edge Attributes
+
+Add/change edge attributes using `add_edge()`, `add_edges_from()`,
+or subscript notation.
+
+```{code-cell}
+G.add_edge(1, 2, weight=4.7 )
+G.add_edges_from([(3, 4), (4, 5)], color='red')
+G.add_edges_from([(1, 2, {'color': 'blue'}), (2, 3, {'weight': 8})])
+G[1][2]['weight'] = 4.7
+G.edges[3, 4]['weight'] = 4.2
+```
+
+The special attribute `weight` should be numeric as it is used by
+algorithms requiring weighted edges.
+
+## Directed graphs
+
+The {class}`DiGraph` class provides additional methods and properties specific
+to directed edges, e.g.,
+{attr}`DiGraph.out_edges`, {attr}`DiGraph.in_degree`,
+{meth}`DiGraph.predecessors`, {meth}`DiGraph.successors` etc.
+To allow algorithms to work with both classes easily, the directed versions of
+{meth}`neighbors <DiGraph.neighbors>` is equivalent to
+{meth}`successors <DiGraph.successors>` while {attr}`DiGraph.degree` reports the sum
+of {attr}`DiGraph.in_degree` and {attr}`DiGraph.out_degree` even though that may
+feel inconsistent at times.
+
+```{code-cell}
+DG = nx.DiGraph()
+DG.add_weighted_edges_from([(1, 2, 0.5), (3, 1, 0.75)])
+DG.out_degree(1, weight='weight')
+```
+
+```{code-cell}
+DG.degree(1, weight='weight')
+```
+
+```{code-cell}
+list(DG.successors(1))
+```
+
+```{code-cell}
+list(DG.neighbors(1))
+```
+
+Some algorithms work only for directed graphs and others are not well
+defined for directed graphs. Indeed the tendency to lump directed
+and undirected graphs together is dangerous. If you want to treat
+a directed graph as undirected for some measurement you should probably
+convert it using {meth}`Graph.to_undirected` or with
+
+```{code-cell}
+H = nx.Graph(G)  # create an undirected graph H from a directed graph G
+```
+
+## Multigraphs
+
+NetworkX provides classes for graphs which allow multiple edges
+between any pair of nodes. The {class}`MultiGraph` and
+{class}`MultiDiGraph`
+classes allow you to add the same edge twice, possibly with different
+edge data. This can be powerful for some applications, but many
+algorithms are not well defined on such graphs.
+Where results are well defined,
+e.g., {meth}`MultiGraph.degree` we provide the function. Otherwise you
+should convert to a standard graph in a way that makes the measurement
+well defined.
+
+```{code-cell}
+MG = nx.MultiGraph()
+MG.add_weighted_edges_from([(1, 2, 0.5), (1, 2, 0.75), (2, 3, 0.5)])
+dict(MG.degree(weight='weight'))
+```
+
+```{code-cell}
+GG = nx.Graph()
+for n, nbrs in MG.adjacency():
+   for nbr, edict in nbrs.items():
+       minvalue = min([d['weight'] for d in edict.values()])
+       GG.add_edge(n, nbr, weight = minvalue)
+
+nx.shortest_path(GG, 1, 3)
+```
+
+## Graph generators and graph operations
+
+In addition to constructing graphs node-by-node or edge-by-edge, they
+can also be generated by
+
+### 1. Applying classic graph operations, such as:
+
+```{eval-rst}
+.. autosummary::
+
+    ~networkx.classes.function.subgraph
+    ~networkx.algorithms.operators.binary.union
+    ~networkx.algorithms.operators.binary.disjoint_union
+    ~networkx.algorithms.operators.product.cartesian_product
+    ~networkx.algorithms.operators.binary.compose
+    ~networkx.algorithms.operators.unary.complement
+    ~networkx.classes.function.create_empty_copy
+    ~networkx.classes.function.to_undirected
+    ~networkx.classes.function.to_directed
+```
+
+### 2. Using a call to one of the classic small graphs, e.g.,
+
+```{eval-rst}
+.. autosummary::
+
+    ~networkx.generators.small.petersen_graph
+    ~networkx.generators.small.tutte_graph
+    ~networkx.generators.small.sedgewick_maze_graph
+    ~networkx.generators.small.tetrahedral_graph
+```
+
+### 3. Using a (constructive) generator for a classic graph, e.g.,
+
+```{eval-rst}
+.. autosummary::
+
+    ~networkx.generators.classic.complete_graph
+    ~networkx.algorithms.bipartite.generators.complete_bipartite_graph
+    ~networkx.generators.classic.barbell_graph
+    ~networkx.generators.classic.lollipop_graph
+```
+
+like so:
+
+```{code-cell}
+K_5 = nx.complete_graph(5)
+K_3_5 = nx.complete_bipartite_graph(3, 5)
+barbell = nx.barbell_graph(10, 10)
+lollipop = nx.lollipop_graph(10, 20)
+```
+
+### 4. Using a stochastic graph generator, e.g,
+
+```{eval-rst}
+.. autosummary::
+
+    ~networkx.generators.random_graphs.erdos_renyi_graph
+    ~networkx.generators.random_graphs.watts_strogatz_graph
+    ~networkx.generators.random_graphs.barabasi_albert_graph
+    ~networkx.generators.random_graphs.random_lobster
+```
+
+like so:
+
+```{code-cell}
+er = nx.erdos_renyi_graph(100, 0.15)
+ws = nx.watts_strogatz_graph(30, 3, 0.1)
+ba = nx.barabasi_albert_graph(100, 5)
+red = nx.random_lobster(100, 0.9, 0.9)
+```
+
+### 5. Reading a graph stored in a file using common graph formats
+
+NetworkX supports many popular formats, such as edge lists, adjacency lists,
+GML, GraphML, LEDA and others.
+
+```{code-cell}
+nx.write_gml(red, "path.to.file")
+mygraph = nx.read_gml("path.to.file")
+```
+
+For details on graph formats see {doc}`/reference/readwrite/index`
+and for graph generator functions see {doc}`/reference/generators`
+
+## Analyzing graphs
+
+The structure of `G` can be analyzed using various graph-theoretic
+functions such as:
+
+```{code-cell}
+G = nx.Graph()
+G.add_edges_from([(1, 2), (1, 3)])
+G.add_node("spam")       # adds node "spam"
+list(nx.connected_components(G))
+```
+
+```{code-cell}
+sorted(d for n, d in G.degree())
+```
+
+```{code-cell}
+nx.clustering(G)
+```
+
+Some functions with large output iterate over (node, value) 2-tuples.
+These are easily stored in a `dict` structure if you desire.
+
+```{code-cell}
+sp = dict(nx.all_pairs_shortest_path(G))
+sp[3]
+```
+
+See {doc}`/reference/algorithms/index` for details on graph algorithms
+supported.
+
+## Drawing graphs
+
+NetworkX is not primarily a graph drawing package but basic drawing with
+Matplotlib as well as an interface to use the open source Graphviz software
+package are included. These are part of the {doc}`networkx.drawing <reference/drawing>`
+module and will be imported if possible.
+
+First import Matplotlib's plot interface (pylab works too)
+
+```{code-cell}
+import matplotlib.pyplot as plt
+```
+
+To test if the import of `~networkx.drawing.nx_pylab` was successful draw `G`
+using one of
+
+```{code-cell}
+G = nx.petersen_graph()
+subax1 = plt.subplot(121)
+nx.draw(G, with_labels=True, font_weight='bold')
+subax2 = plt.subplot(122)
+nx.draw_shell(G, nlist=[range(5, 10), range(5)], with_labels=True, font_weight='bold')
+```
+
+when drawing to an interactive display. Note that you may need to issue a
+Matplotlib
+
+```python
+plt.show()
+```
+
+command if you are not using matplotlib in interactive mode.
+
+```{code-cell}
+options = {
+    'node_color': 'black',
+    'node_size': 100,
+    'width': 3,
+}
+subax1 = plt.subplot(221)
+nx.draw_random(G, **options)
+subax2 = plt.subplot(222)
+nx.draw_circular(G, **options)
+subax3 = plt.subplot(223)
+nx.draw_spectral(G, **options)
+subax4 = plt.subplot(224)
+nx.draw_shell(G, nlist=[range(5,10), range(5)], **options)
+```
+
+You can find additional options via {func}`~drawing.nx_pylab.draw_networkx` and
+layouts via the {mod}`layout module<networkx.drawing.layout>`.
+You can use multiple shells with {func}`~drawing.nx_pylab.draw_shell`.
+
+```{code-cell}
+G = nx.dodecahedral_graph()
+shells = [[2, 3, 4, 5, 6], [8, 1, 0, 19, 18, 17, 16, 15, 14, 7], [9, 10, 11, 12, 13]]
+nx.draw_shell(G, nlist=shells, **options)
+```
+
+To save drawings to a file, use, for example
+
+```pycon
+>>> nx.draw(G)
+>>> plt.savefig("path.png")
+```
+
+This function writes to the file `path.png` in the local directory. If Graphviz and
+PyGraphviz or pydot, are available on your system, you can also use
+`networkx.drawing.nx_agraph.graphviz_layout` or
+`networkx.drawing.nx_pydot.graphviz_layout` to get the node positions, or write
+the graph in dot format for further processing.
+
+```pycon
+>>> from networkx.drawing.nx_pydot import write_dot
+>>> pos = nx.nx_agraph.graphviz_layout(G)
+>>> nx.draw(G, pos=pos)
+>>> write_dot(G, 'file.dot')
+```
+
+See {doc}`/reference/drawing` for additional details.
+
+## NX-Guides
+
+If you are interested in learning more about NetworkX, graph theory and network analysis
+then you should check out {doc}`nx-guides <nx-guides:index>`. There you can find tutorials,
+real-world applications and in-depth examinations of graphs and network algorithms.
+All the material is official and was developed and curated by the NetworkX community.
diff --git a/doc/tutorial.rst b/doc/tutorial.rst
deleted file mode 100644
index 43f54b69fd0..00000000000
--- a/doc/tutorial.rst
+++ /dev/null
@@ -1,635 +0,0 @@
-Tutorial
-========
-
-.. currentmodule:: networkx
-
-This guide can help you start working with NetworkX.
-
-Creating a graph
-----------------
-
-Create an empty graph with no nodes and no edges.
-
-.. nbplot::
-
-    >>> import networkx as nx
-    >>> G = nx.Graph()
-
-By definition, a :class:`Graph` is a collection of nodes (vertices) along with
-identified pairs of nodes (called edges, links, etc).  In NetworkX, nodes can
-be any :py:term:`hashable` object e.g., a text string, an image, an XML object,
-another Graph, a customized node object, etc.
-
-.. note:: Python's ``None`` object is not allowed to be used as a node. It
-    determines whether optional function arguments have been assigned in many
-    functions.
-
-Nodes
------
-
-The graph ``G`` can be grown in several ways.  NetworkX includes many
-:doc:`graph generator functions <reference/generators>` and
-:doc:`facilities to read and write graphs in many formats <reference/readwrite/index>`.
-To get started though we'll look at simple manipulations.  You can add one node
-at a time,
-
-.. nbplot::
-
-    >>> G.add_node(1)
-
-or add nodes from any :py:term:`iterable` container, such as a list
-
-.. nbplot::
-
-    >>> G.add_nodes_from([2, 3])
-
-You can also add nodes along with node
-attributes if your container yields 2-tuples of the form 
-``(node, node_attribute_dict)``::
-
-    >>> G.add_nodes_from([
-    ...     (4, {"color": "red"}),
-    ...     (5, {"color": "green"}),
-    ... ])
-
-Node attributes are discussed further :ref:`below <attributes>`.
-
-Nodes from one graph can be incorporated into another:
-
-.. nbplot::
-
-    >>> H = nx.path_graph(10)
-    >>> G.add_nodes_from(H)
-
-``G`` now contains the nodes of ``H`` as nodes of ``G``.
-In contrast, you could use the graph ``H`` as a node in ``G``.
-
-.. nbplot::
-
-    >>> G.add_node(H)
-
-The graph ``G`` now contains ``H`` as a node.  This flexibility is very powerful as
-it allows graphs of graphs, graphs of files, graphs of functions and much more.
-It is worth thinking about how to structure your application so that the nodes
-are useful entities.  Of course you can always use a unique identifier in ``G``
-and have a separate dictionary keyed by identifier to the node information if
-you prefer.
-
-.. note:: You should not change the node object if the hash depends
-   on its contents.
-
-Edges
------
-
-``G`` can also be grown by adding one edge at a time,
-
-.. nbplot::
-
-    >>> G.add_edge(1, 2)
-    >>> e = (2, 3)
-    >>> G.add_edge(*e)  # unpack edge tuple*
-
-by adding a list of edges,
-
-.. nbplot::
-
-    >>> G.add_edges_from([(1, 2), (1, 3)])
-
-or by adding any :term:`ebunch` of edges.  An *ebunch* is any iterable
-container of edge-tuples.  An edge-tuple can be a 2-tuple of nodes or a 3-tuple
-with 2 nodes followed by an edge attribute dictionary, e.g.,
-``(2, 3, {'weight': 3.1415})``.  Edge attributes are discussed further
-:ref:`below <attributes>`.
-
-.. nbplot::
-
-    >>> G.add_edges_from(H.edges)
-
-There are no complaints when adding existing nodes or edges. For example,
-after removing all nodes and edges,
-
-.. nbplot::
-
-    >>> G.clear()
-
-we add new nodes/edges and NetworkX quietly ignores any that are
-already present.
-
-.. nbplot::
-
-    >>> G.add_edges_from([(1, 2), (1, 3)])
-    >>> G.add_node(1)
-    >>> G.add_edge(1, 2)
-    >>> G.add_node("spam")        # adds node "spam"
-    >>> G.add_nodes_from("spam")  # adds 4 nodes: 's', 'p', 'a', 'm'
-    >>> G.add_edge(3, 'm')
-
-At this stage the graph ``G`` consists of 8 nodes and 3 edges, as can be seen by:
-
-.. nbplot::
-
-    >>> G.number_of_nodes()
-    8
-    >>> G.number_of_edges()
-    3
-
-.. note:: 
-   
-   The order of adjacency reporting (e.g., :meth:`G.adj <networkx.Graph.adj>`,
-   :meth:`G.successors <networkx.DiGraph.successors>`,
-   :meth:`G.predecessors <networkx.DiGraph.predecessors>`) is the order of
-   edge addition. However, the order of G.edges is the order of the adjacencies
-   which includes both the order of the nodes and each 
-   node's adjacencies. See example below:
-
-.. nbplot::
-
-    >>> DG = nx.DiGraph()
-    >>> DG.add_edge(2, 1)   # adds the nodes in order 2, 1
-    >>> DG.add_edge(1, 3)
-    >>> DG.add_edge(2, 4)
-    >>> DG.add_edge(1, 2)
-    >>> assert list(DG.successors(2)) == [1, 4]
-    >>> assert list(DG.edges) == [(2, 1), (2, 4), (1, 3), (1, 2)]
-
-Examining elements of a graph
------------------------------
-
-We can examine the nodes and edges. Four basic graph properties facilitate
-reporting: ``G.nodes``, ``G.edges``, ``G.adj`` and ``G.degree``.  These
-are set-like views of the nodes, edges, neighbors (adjacencies), and degrees
-of nodes in a graph. They offer a continually updated read-only view into
-the graph structure. They are also dict-like in that you can look up node
-and edge data attributes via the views and iterate with data attributes
-using methods ``.items()``, ``.data()``.
-If you want a specific container type instead of a view, you can specify one.
-Here we use lists, though sets, dicts, tuples and other containers may be
-better in other contexts.
-
-.. nbplot::
-
-    >>> list(G.nodes)
-    [1, 2, 3, 'spam', 's', 'p', 'a', 'm']
-    >>> list(G.edges)
-    [(1, 2), (1, 3), (3, 'm')]
-    >>> list(G.adj[1])  # or list(G.neighbors(1))
-    [2, 3]
-    >>> G.degree[1]  # the number of edges incident to 1
-    2
-
-One can specify to report the edges and degree from a subset of all nodes
-using an :term:`nbunch`. An *nbunch* is any of: ``None`` (meaning all nodes),
-a node, or an iterable container of nodes that is not itself a node in the
-graph.
-
-.. nbplot::
-
-    >>> G.edges([2, 'm'])
-    EdgeDataView([(2, 1), ('m', 3)])
-    >>> G.degree([2, 3])
-    DegreeView({2: 1, 3: 2})
-
-Removing elements from a graph
-------------------------------
-
-One can remove nodes and edges from the graph in a similar fashion to adding.
-Use methods
-:meth:`Graph.remove_node`,
-:meth:`Graph.remove_nodes_from`,
-:meth:`Graph.remove_edge`
-and
-:meth:`Graph.remove_edges_from`, e.g.
-
-.. nbplot::
-
-    >>> G.remove_node(2)
-    >>> G.remove_nodes_from("spam")
-    >>> list(G.nodes)
-    [1, 3, 'spam']
-    >>> G.remove_edge(1, 3)
-
-Using the graph constructors
-----------------------------
-
-Graph objects do not have to be built up incrementally - data specifying
-graph structure can be passed directly to the constructors of the various
-graph classes.
-When creating a graph structure by instantiating one of the graph
-classes you can specify data in several formats.
-
-.. nbplot::
-
-    >>> G.add_edge(1, 2)
-    >>> H = nx.DiGraph(G)  # create a DiGraph using the connections from G
-    >>> list(H.edges())
-    [(1, 2), (2, 1)]
-    >>> edgelist = [(0, 1), (1, 2), (2, 3)]
-    >>> H = nx.Graph(edgelist)  # create a graph from an edge list
-    >>> list(H.edges())
-    [(0, 1), (1, 2), (2, 3)]
-    >>> adjacency_dict = {0: (1, 2), 1: (0, 2), 2: (0, 1)}
-    >>> H = nx.Graph(adjacency_dict)  # create a Graph dict mapping nodes to nbrs
-    >>> list(H.edges())
-    [(0, 1), (0, 2), (1, 2)]
-
-What to use as nodes and edges
-------------------------------
-
-You might notice that nodes and edges are not specified as NetworkX
-objects.  This leaves you free to use meaningful items as nodes and
-edges. The most common choices are numbers or strings, but a node can
-be any hashable object (except ``None``), and an edge can be associated
-with any object ``x`` using ``G.add_edge(n1, n2, object=x)``.
-
-As an example, ``n1`` and ``n2`` could be protein objects from the RCSB Protein
-Data Bank, and ``x`` could refer to an XML record of publications detailing
-experimental observations of their interaction.
-
-We have found this power quite useful, but its abuse
-can lead to surprising behavior unless one is familiar with Python.
-If in doubt, consider using :func:`~relabel.convert_node_labels_to_integers` to obtain
-a more traditional graph with integer labels.
-
-Accessing edges and neighbors
------------------------------
-
-In addition to the views :attr:`Graph.edges`, and :attr:`Graph.adj`,
-access to edges and neighbors is possible using subscript notation.
-
-.. nbplot::
-
-    >>> G = nx.Graph([(1, 2, {"color": "yellow"})])
-    >>> G[1]  # same as G.adj[1]
-    AtlasView({2: {'color': 'yellow'}})
-    >>> G[1][2]
-    {'color': 'yellow'}
-    >>> G.edges[1, 2]
-    {'color': 'yellow'}
-
-You can get/set the attributes of an edge using subscript notation
-if the edge already exists.
-
-.. nbplot::
-
-    >>> G.add_edge(1, 3)
-    >>> G[1][3]['color'] = "blue"
-    >>> G.edges[1, 2]['color'] = "red"
-    >>> G.edges[1, 2]
-    {'color': 'red'}
-
-Fast examination of all (node, adjacency) pairs is achieved using
-``G.adjacency()``, or ``G.adj.items()``.
-Note that for undirected graphs, adjacency iteration sees each edge twice.
-
-.. nbplot::
-
-    >>> FG = nx.Graph()
-    >>> FG.add_weighted_edges_from([(1, 2, 0.125), (1, 3, 0.75), (2, 4, 1.2), (3, 4, 0.375)])
-    >>> for n, nbrs in FG.adj.items():
-    ...    for nbr, eattr in nbrs.items():
-    ...        wt = eattr['weight']
-    ...        if wt < 0.5: print(f"({n}, {nbr}, {wt:.3})")
-    (1, 2, 0.125)
-    (2, 1, 0.125)
-    (3, 4, 0.375)
-    (4, 3, 0.375)
-
-Convenient access to all edges is achieved with the edges property.
-
-.. nbplot::
-
-    >>> for (u, v, wt) in FG.edges.data('weight'):
-    ...     if wt < 0.5:
-    ...         print(f"({u}, {v}, {wt:.3})")
-    (1, 2, 0.125)
-    (3, 4, 0.375)
-
-.. _attributes:
-
-Adding attributes to graphs, nodes, and edges
----------------------------------------------
-
-Attributes such as weights, labels, colors, or whatever Python object you like,
-can be attached to graphs, nodes, or edges.
-
-Each graph, node, and edge can hold key/value attribute pairs in an associated
-attribute dictionary (the keys must be hashable).  By default these are empty,
-but attributes can be added or changed using ``add_edge``, ``add_node`` or direct
-manipulation of the attribute dictionaries named ``G.graph``, ``G.nodes``, and
-``G.edges`` for a graph ``G``.
-
-Graph attributes
-~~~~~~~~~~~~~~~~
-
-Assign graph attributes when creating a new graph
-
-.. nbplot::
-
-    >>> G = nx.Graph(day="Friday")
-    >>> G.graph
-    {'day': 'Friday'}
-
-Or you can modify attributes later
-
-.. nbplot::
-
-    >>> G.graph['day'] = "Monday"
-    >>> G.graph
-    {'day': 'Monday'}
-
-Node attributes
-~~~~~~~~~~~~~~~
-
-Add node attributes using ``add_node()``, ``add_nodes_from()``, or ``G.nodes``
-
-.. nbplot::
-
-    >>> G.add_node(1, time='5pm')
-    >>> G.add_nodes_from([3], time='2pm')
-    >>> G.nodes[1]
-    {'time': '5pm'}
-    >>> G.nodes[1]['room'] = 714
-    >>> G.nodes.data()
-    NodeDataView({1: {'time': '5pm', 'room': 714}, 3: {'time': '2pm'}})
-
-Note that adding a node to ``G.nodes`` does not add it to the graph, use
-``G.add_node()`` to add new nodes. Similarly for edges.
-
-Edge Attributes
-~~~~~~~~~~~~~~~
-
-Add/change edge attributes using ``add_edge()``, ``add_edges_from()``,
-or subscript notation.
-
-.. nbplot::
-
-    >>> G.add_edge(1, 2, weight=4.7 )
-    >>> G.add_edges_from([(3, 4), (4, 5)], color='red')
-    >>> G.add_edges_from([(1, 2, {'color': 'blue'}), (2, 3, {'weight': 8})])
-    >>> G[1][2]['weight'] = 4.7
-    >>> G.edges[3, 4]['weight'] = 4.2
-
-The special attribute ``weight`` should be numeric as it is used by
-algorithms requiring weighted edges.
-
-Directed graphs
----------------
-
-The :class:`DiGraph` class provides additional methods and properties specific
-to directed edges, e.g.,
-:attr:`DiGraph.out_edges`, :attr:`DiGraph.in_degree`,
-`DiGraph.predecessors`, `DiGraph.successors` etc.
-To allow algorithms to work with both classes easily, the directed versions of
-:meth:`neighbors <DiGraph.neighbors>` is equivalent to
-`successors <DiGraph.successors>` while `~DiGraph.degree` reports the sum
-of `~DiGraph.in_degree` and `~DiGraph.out_degree` even though that may feel inconsistent at times.
-
-.. nbplot::
-
-    >>> DG = nx.DiGraph()
-    >>> DG.add_weighted_edges_from([(1, 2, 0.5), (3, 1, 0.75)])
-    >>> DG.out_degree(1, weight='weight')
-    0.5
-    >>> DG.degree(1, weight='weight')
-    1.25
-    >>> list(DG.successors(1))
-    [2]
-    >>> list(DG.neighbors(1))
-    [2]
-
-Some algorithms work only for directed graphs and others are not well
-defined for directed graphs.  Indeed the tendency to lump directed
-and undirected graphs together is dangerous.  If you want to treat
-a directed graph as undirected for some measurement you should probably
-convert it using :meth:`Graph.to_undirected` or with
-
-.. nbplot::
-
-    >>> H = nx.Graph(G)  # create an undirected graph H from a directed graph G
-
-Multigraphs
------------
-
-NetworkX provides classes for graphs which allow multiple edges
-between any pair of nodes.  The :class:`MultiGraph` and
-:class:`MultiDiGraph`
-classes allow you to add the same edge twice, possibly with different
-edge data.  This can be powerful for some applications, but many
-algorithms are not well defined on such graphs.
-Where results are well defined,
-e.g., :meth:`MultiGraph.degree` we provide the function.  Otherwise you
-should convert to a standard graph in a way that makes the measurement
-well defined.
-
-.. nbplot::
-
-    >>> MG = nx.MultiGraph()
-    >>> MG.add_weighted_edges_from([(1, 2, 0.5), (1, 2, 0.75), (2, 3, 0.5)])
-    >>> dict(MG.degree(weight='weight'))
-    {1: 1.25, 2: 1.75, 3: 0.5}
-    >>> GG = nx.Graph()
-    >>> for n, nbrs in MG.adjacency():
-    ...    for nbr, edict in nbrs.items():
-    ...        minvalue = min([d['weight'] for d in edict.values()])
-    ...        GG.add_edge(n, nbr, weight = minvalue)
-    ...
-    >>> nx.shortest_path(GG, 1, 3)
-    [1, 2, 3]
-
-Graph generators and graph operations
--------------------------------------
-
-In addition to constructing graphs node-by-node or edge-by-edge, they
-can also be generated by
-
-1. Applying classic graph operations, such as:
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autosummary::
-
-    ~networkx.classes.function.subgraph
-    ~networkx.algorithms.operators.binary.union
-    ~networkx.algorithms.operators.binary.disjoint_union
-    ~networkx.algorithms.operators.product.cartesian_product
-    ~networkx.algorithms.operators.binary.compose
-    ~networkx.algorithms.operators.unary.complement
-    ~networkx.classes.function.create_empty_copy
-    ~networkx.classes.function.to_undirected
-    ~networkx.classes.function.to_directed
-
-2. Using a call to one of the classic small graphs, e.g.,
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autosummary::
-
-    ~networkx.generators.small.petersen_graph
-    ~networkx.generators.small.tutte_graph
-    ~networkx.generators.small.sedgewick_maze_graph
-    ~networkx.generators.small.tetrahedral_graph
-
-3. Using a (constructive) generator for a classic graph, e.g.,
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autosummary::
-
-    ~networkx.generators.classic.complete_graph
-    ~networkx.algorithms.bipartite.generators.complete_bipartite_graph
-    ~networkx.generators.classic.barbell_graph
-    ~networkx.generators.classic.lollipop_graph
-
-like so:
-
-.. nbplot::
-
-    >>> K_5 = nx.complete_graph(5)
-    >>> K_3_5 = nx.complete_bipartite_graph(3, 5)
-    >>> barbell = nx.barbell_graph(10, 10)
-    >>> lollipop = nx.lollipop_graph(10, 20)
-
-4. Using a stochastic graph generator, e.g,
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. autosummary::
-
-    ~networkx.generators.random_graphs.erdos_renyi_graph
-    ~networkx.generators.random_graphs.watts_strogatz_graph
-    ~networkx.generators.random_graphs.barabasi_albert_graph
-    ~networkx.generators.random_graphs.random_lobster
-
-like so:
-
-.. nbplot::
-
-    >>> er = nx.erdos_renyi_graph(100, 0.15)
-    >>> ws = nx.watts_strogatz_graph(30, 3, 0.1)
-    >>> ba = nx.barabasi_albert_graph(100, 5)
-    >>> red = nx.random_lobster(100, 0.9, 0.9)
-
-5. Reading a graph stored in a file using common graph formats
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-NetworkX supports many popular formats, such as edge lists, adjacency lists,
-GML, GraphML, LEDA and others.
-
-.. nbplot::
-
-    >>> nx.write_gml(red, "path.to.file")
-    >>> mygraph = nx.read_gml("path.to.file")
-
-For details on graph formats see :doc:`/reference/readwrite/index`
-and for graph generator functions see :doc:`/reference/generators`
-
-Analyzing graphs
-----------------
-
-The structure of ``G`` can be analyzed using various graph-theoretic
-functions such as:
-
-.. nbplot::
-
-    >>> G = nx.Graph()
-    >>> G.add_edges_from([(1, 2), (1, 3)])
-    >>> G.add_node("spam")       # adds node "spam"
-    >>> list(nx.connected_components(G))
-    [{1, 2, 3}, {'spam'}]
-    >>> sorted(d for n, d in G.degree())
-    [0, 1, 1, 2]
-    >>> nx.clustering(G)
-    {1: 0, 2: 0, 3: 0, 'spam': 0}
-
-Some functions with large output iterate over (node, value) 2-tuples.
-These are easily stored in a `dict` structure if you desire.
-
-.. nbplot::
-
-    >>> sp = dict(nx.all_pairs_shortest_path(G))
-    >>> sp[3]
-    {3: [3], 1: [3, 1], 2: [3, 1, 2]}
-
-See :doc:`/reference/algorithms/index` for details on graph algorithms
-supported.
-
-Drawing graphs
---------------
-
-NetworkX is not primarily a graph drawing package but basic drawing with
-Matplotlib as well as an interface to use the open source Graphviz software
-package are included.  These are part of the :doc:`networkx.drawing <reference/drawing>`
-module and will be imported if possible.
-
-First import Matplotlib's plot interface (pylab works too)
-
-.. nbplot::
-
-    >>> import matplotlib.pyplot as plt
-
-To test if the import of `~networkx.drawing.nx_pylab` was successful draw ``G``
-using one of
-
-.. nbplot::
-
-    >>> G = nx.petersen_graph()
-    >>> subax1 = plt.subplot(121)
-    >>> nx.draw(G, with_labels=True, font_weight='bold')
-    >>> subax2 = plt.subplot(122)
-    >>> nx.draw_shell(G, nlist=[range(5, 10), range(5)], with_labels=True, font_weight='bold')
-
-when drawing to an interactive display.  Note that you may need to issue a
-Matplotlib
-
->>> plt.show()  # doctest: +SKIP
-
-command if you are not using matplotlib in interactive mode.
-
-.. nbplot::
-
-    >>> options = {
-    ...     'node_color': 'black',
-    ...     'node_size': 100,
-    ...     'width': 3,
-    ... }
-    >>> subax1 = plt.subplot(221)
-    >>> nx.draw_random(G, **options)
-    >>> subax2 = plt.subplot(222)
-    >>> nx.draw_circular(G, **options)
-    >>> subax3 = plt.subplot(223)
-    >>> nx.draw_spectral(G, **options)
-    >>> subax4 = plt.subplot(224)
-    >>> nx.draw_shell(G, nlist=[range(5,10), range(5)], **options)
-
-You can find additional options via :func:`~drawing.nx_pylab.draw_networkx` and
-layouts via the :mod:`layout module<networkx.drawing.layout>`.
-You can use multiple shells with :func:`~drawing.nx_pylab.draw_shell`.
-
-.. nbplot::
-
-    >>> G = nx.dodecahedral_graph()
-    >>> shells = [[2, 3, 4, 5, 6], [8, 1, 0, 19, 18, 17, 16, 15, 14, 7], [9, 10, 11, 12, 13]]
-    >>> nx.draw_shell(G, nlist=shells, **options)
-
-To save drawings to a file, use, for example
-
->>> nx.draw(G)
->>> plt.savefig("path.png")
-
-This function writes to the file ``path.png`` in the local directory. If Graphviz and
-PyGraphviz or pydot, are available on your system, you can also use
-`networkx.drawing.nx_agraph.graphviz_layout` or
-`networkx.drawing.nx_pydot.graphviz_layout` to get the node positions, or write
-the graph in dot format for further processing.
-
->>> from networkx.drawing.nx_pydot import write_dot
->>> pos = nx.nx_agraph.graphviz_layout(G)
->>> nx.draw(G, pos=pos)
->>> write_dot(G, 'file.dot')
-
-See :doc:`/reference/drawing` for additional details.
-
-.. code-links::
-
-NX-Guides
----------
-If you are interested in learning more about NetworkX, graph theory and network analysis 
-then you should check out :doc:`nx-guides <nx-guides:index>`. There you can find tutorials,
-real-world applications and in-depth examinations of graphs and network algorithms. 
-All the material is official and was developed and curated by the NetworkX community. 
diff --git a/pyproject.toml b/pyproject.toml
index dd6abc72cee..47be7f9a6d3 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -72,8 +72,8 @@ doc = [
     'sphinx-gallery>=0.14',
     'numpydoc>=1.6',
     'pillow>=9.4',
-    'nb2plots>=0.7',
     'texext>=0.6.7',
+    'myst-nb>=1.0',
 ]
 extra = [
     'lxml>=4.6',
diff --git a/requirements/doc.txt b/requirements/doc.txt
index 73cc513adcd..7fe8fea6a22 100644
--- a/requirements/doc.txt
+++ b/requirements/doc.txt
@@ -5,5 +5,5 @@ pydata-sphinx-theme>=0.14
 sphinx-gallery>=0.14
 numpydoc>=1.6
 pillow>=9.4
-nb2plots>=0.7
 texext>=0.6.7
+myst-nb>=1.0

From 8bc625b5e0a057268d7a141ae130a22da7b013ca Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Thu, 15 Feb 2024 04:09:47 -0800
Subject: [PATCH 072/129]  Move arrowstyle input munging after intput
 validation.  (#7293)

* Add test for spurious user warning.

Revert accidental benchmark conf changes.

* Move arrowstyle input munging after intput validation.

A UserWarning is raised on the value of arrowstyle, but the value
is modified internally before this validation is performed.

Move the modification *after* the validation step to suppress the
spurious warnings.

* TST: category kwarg not available until Python 3.11
---
 networkx/drawing/nx_pylab.py         |  7 ++++---
 networkx/drawing/tests/test_pylab.py | 12 ++++++++++++
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/networkx/drawing/nx_pylab.py b/networkx/drawing/nx_pylab.py
index 727111fb7ce..6171c0f7d9a 100644
--- a/networkx/drawing/nx_pylab.py
+++ b/networkx/drawing/nx_pylab.py
@@ -858,9 +858,6 @@ def draw_networkx_edges(
             raise TypeError("Argument `arrows` must be of type bool or None")
         use_linecollection = not arrows
 
-    if arrowstyle is None:
-        arrowstyle = "-|>" if G.is_directed() else "-"
-
     if isinstance(connectionstyle, str):
         connectionstyle = [connectionstyle]
     elif np.iterable(connectionstyle):
@@ -897,6 +894,10 @@ def draw_networkx_edges(
                 msg.format("connectionstyle"), category=UserWarning, stacklevel=2
             )
 
+    # NOTE: Arrowstyle modification must occur after the warnings section
+    if arrowstyle is None:
+        arrowstyle = "-|>" if G.is_directed() else "-"
+
     if ax is None:
         ax = plt.gca()
 
diff --git a/networkx/drawing/tests/test_pylab.py b/networkx/drawing/tests/test_pylab.py
index bfc22627347..38f92964d6e 100644
--- a/networkx/drawing/tests/test_pylab.py
+++ b/networkx/drawing/tests/test_pylab.py
@@ -833,3 +833,15 @@ def test_user_warnings_for_unused_edge_drawing_kwargs(fap_only_kwarg):
         nx.draw_networkx_edges(G, pos, ax=ax, arrows=True, **fap_only_kwarg)
 
     plt.delaxes(ax)
+
+
+@pytest.mark.parametrize("draw_fn", (nx.draw, nx.draw_circular))
+def test_no_warning_on_default_draw_arrowstyle(draw_fn):
+    # See gh-7284
+    fig, ax = plt.subplots()
+    G = nx.cycle_graph(5)
+    with warnings.catch_warnings(record=True) as w:
+        draw_fn(G, ax=ax)
+    assert len(w) == 0
+
+    plt.delaxes(ax)

From fce5d7d58d1a50ccc94419e888be3ff4fd8b61aa Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Thu, 15 Feb 2024 05:14:14 -0800
Subject: [PATCH 073/129] Temporarily rm geospatial examples to fix CI. (#7299)

Renames a couple geospatial examples from the gallery
for which contextily.add_basemap is failing, causing the doc
CI to fail.
---
 examples/geospatial/{plot_delaunay.py => delaunay.py} | 0
 examples/geospatial/{plot_lines.py => lines.py}       | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename examples/geospatial/{plot_delaunay.py => delaunay.py} (100%)
 rename examples/geospatial/{plot_lines.py => lines.py} (100%)

diff --git a/examples/geospatial/plot_delaunay.py b/examples/geospatial/delaunay.py
similarity index 100%
rename from examples/geospatial/plot_delaunay.py
rename to examples/geospatial/delaunay.py
diff --git a/examples/geospatial/plot_lines.py b/examples/geospatial/lines.py
similarity index 100%
rename from examples/geospatial/plot_lines.py
rename to examples/geospatial/lines.py

From 242a02ad8c2c3c9993073c82a7d087caa20525fa Mon Sep 17 00:00:00 2001
From: Matthieu Gouel <matthieu.gouel@protonmail.com>
Date: Thu, 15 Feb 2024 14:24:38 +0100
Subject: [PATCH 074/129] BFS layout implementation (#5179)

* first BFS layout implementation

* use of multipartite layout in bfs layout

* Add some nominal test cases for bfs_layout.

* Apply suggestions from code review

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>

* fix style

* add option of dict to multipartite_layout, use it from bfs_layout

* connect bsf_layout to docs

* Add test case for non-connected graphs.

* Apply latest pre-commit.

---------

Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 doc/reference/drawing.rst             |  1 +
 networkx/drawing/layout.py            | 87 +++++++++++++++++++++++----
 networkx/drawing/tests/test_layout.py | 48 ++++++++++++++-
 3 files changed, 122 insertions(+), 14 deletions(-)

diff --git a/doc/reference/drawing.rst b/doc/reference/drawing.rst
index daf094998dd..63853e0abe0 100644
--- a/doc/reference/drawing.rst
+++ b/doc/reference/drawing.rst
@@ -84,6 +84,7 @@ Graph Layout
    :toctree: generated/
 
    bipartite_layout
+   bfs_layout
    circular_layout
    kamada_kawai_layout
    planar_layout
diff --git a/networkx/drawing/layout.py b/networkx/drawing/layout.py
index fa120d67074..0167df56836 100644
--- a/networkx/drawing/layout.py
+++ b/networkx/drawing/layout.py
@@ -32,6 +32,7 @@
     "fruchterman_reingold_layout",
     "spiral_layout",
     "multipartite_layout",
+    "bfs_layout",
     "arf_layout",
 ]
 
@@ -1030,8 +1031,9 @@ def multipartite_layout(G, subset_key="subset", align="vertical", scale=1, cente
     G : NetworkX graph or list of nodes
         A position will be assigned to every node in G.
 
-    subset_key : string (default='subset')
-        Key of node data to be used as layer subset.
+    subset_key : string or dict (default='subset')
+        If a string, the key of node data in G that holds the node subset.
+        If a dict, keyed by layer number to the nodes in that layer/subset.
 
     align : string (default='vertical')
         The alignment of nodes. Vertical or horizontal.
@@ -1052,6 +1054,12 @@ def multipartite_layout(G, subset_key="subset", align="vertical", scale=1, cente
     >>> G = nx.complete_multipartite_graph(28, 16, 10)
     >>> pos = nx.multipartite_layout(G)
 
+    or use a dict to provide the layers of the layout
+
+    >>> G = nx.Graph([(0, 1), (1, 2), (1, 3), (3, 4)])
+    >>> layers = {"a": [0], "b": [1], "c": [2, 3], "d": [4]}
+    >>> pos = nx.multipartite_layout(G, subset_key=layers)
+
     Notes
     -----
     This algorithm currently only works in two dimensions and does not
@@ -1071,25 +1079,31 @@ def multipartite_layout(G, subset_key="subset", align="vertical", scale=1, cente
     if len(G) == 0:
         return {}
 
-    layers = {}
-    for v, data in G.nodes(data=True):
-        try:
-            layer = data[subset_key]
-        except KeyError:
-            msg = "all nodes must have subset_key (default='subset') as data"
-            raise ValueError(msg)
-        layers[layer] = [v] + layers.get(layer, [])
+    try:
+        # check if subset_key is dict-like
+        if len(G) != sum(len(nodes) for nodes in subset_key.values()):
+            raise nx.NetworkXError(
+                "all nodes must be in one subset of `subset_key` dict"
+            )
+    except AttributeError:
+        # subset_key is not a dict, hence a string
+        node_to_subset = nx.get_node_attributes(G, subset_key)
+        if len(node_to_subset) != len(G):
+            raise nx.NetworkXError(
+                f"all nodes need a subset_key attribute: {subset_key}"
+            )
+        subset_key = nx.utils.groups(node_to_subset)
 
     # Sort by layer, if possible
     try:
-        layers = sorted(layers.items())
+        layers = dict(sorted(subset_key.items()))
     except TypeError:
-        layers = list(layers.items())
+        layers = subset_key
 
     pos = None
     nodes = []
     width = len(layers)
-    for i, (_, layer) in enumerate(layers):
+    for i, layer in enumerate(layers.values()):
         height = len(layer)
         xs = np.repeat(i, height)
         ys = np.arange(0, height, dtype=float)
@@ -1295,3 +1309,50 @@ def rescale_layout_dict(pos, scale=1):
     pos_v = np.array(list(pos.values()))
     pos_v = rescale_layout(pos_v, scale=scale)
     return dict(zip(pos, pos_v))
+
+
+def bfs_layout(G, start, *, align="vertical", scale=1, center=None):
+    """Position nodes according to breadth-first search algorithm.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        A position will be assigned to every node in G.
+
+    start : node in `G`
+        Starting node for bfs
+
+    center : array-like or None
+        Coordinate pair around which to center the layout.
+
+    Returns
+    -------
+    pos : dict
+        A dictionary of positions keyed by node.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> pos = nx.bfs_layout(G, 0)
+
+    Notes
+    -----
+    This algorithm currently only works in two dimensions and does not
+    try to minimize edge crossings.
+
+    """
+    G, center = _process_params(G, center, 2)
+
+    # Compute layers with BFS
+    layers = dict(enumerate(nx.bfs_layers(G, start)))
+
+    if len(G) != sum(len(nodes) for nodes in layers.values()):
+        raise nx.NetworkXError(
+            "bfs_layout didn't include all nodes. Perhaps use input graph:\n"
+            "        G.subgraph(nx.node_connected_component(G, start))"
+        )
+
+    # Compute node positions with multipartite_layout
+    return multipartite_layout(
+        G, subset_key=layers, align=align, scale=scale, center=center
+    )
diff --git a/networkx/drawing/tests/test_layout.py b/networkx/drawing/tests/test_layout.py
index 48d0e6d9d88..3b689458abd 100644
--- a/networkx/drawing/tests/test_layout.py
+++ b/networkx/drawing/tests/test_layout.py
@@ -452,12 +452,18 @@ def test_multipartite_layout_layer_order():
     """Return the layers in sorted order if the layers of the multipartite
     graph are sortable. See gh-5691"""
     G = nx.Graph()
-    for node, layer in zip(("a", "b", "c", "d", "e"), (2, 3, 1, 2, 4)):
+    node_group = dict(zip(("a", "b", "c", "d", "e"), (2, 3, 1, 2, 4)))
+    for node, layer in node_group.items():
         G.add_node(node, subset=layer)
 
     # Horizontal alignment, therefore y-coord determines layers
     pos = nx.multipartite_layout(G, align="horizontal")
 
+    layers = nx.utils.groups(node_group)
+    pos_from_layers = nx.multipartite_layout(G, align="horizontal", subset_key=layers)
+    for (n1, p1), (n2, p2) in zip(pos.items(), pos_from_layers.items()):
+        assert n1 == n2 and (p1 == p2).all()
+
     # Nodes "a" and "d" are in the same layer
     assert pos["a"][-1] == pos["d"][-1]
     # positions should be sorted according to layer
@@ -467,3 +473,43 @@ def test_multipartite_layout_layer_order():
     G.nodes["a"]["subset"] = "layer_0"  # Can't sort mixed strs/ints
     pos_nosort = nx.multipartite_layout(G)  # smoke test: this should not raise
     assert pos_nosort.keys() == pos.keys()
+
+
+def _num_nodes_per_bfs_layer(pos):
+    """Helper function to extract the number of nodes in each layer of bfs_layout"""
+    x = np.array(list(pos.values()))[:, 0]  # node positions in layered dimension
+    _, layer_count = np.unique(x, return_counts=True)
+    return layer_count
+
+
+@pytest.mark.parametrize("n", range(2, 7))
+def test_bfs_layout_complete_graph(n):
+    """The complete graph should result in two layers: the starting node and
+    a second layer containing all neighbors."""
+    G = nx.complete_graph(n)
+    pos = nx.bfs_layout(G, start=0)
+    assert np.array_equal(_num_nodes_per_bfs_layer(pos), [1, n - 1])
+
+
+def test_bfs_layout_barbell():
+    G = nx.barbell_graph(5, 3)
+    # Start in one of the "bells"
+    pos = nx.bfs_layout(G, start=0)
+    # start, bell-1, [1] * len(bar)+1, bell-1
+    expected_nodes_per_layer = [1, 4, 1, 1, 1, 1, 4]
+    assert np.array_equal(_num_nodes_per_bfs_layer(pos), expected_nodes_per_layer)
+    # Start in the other "bell" - expect same layer pattern
+    pos = nx.bfs_layout(G, start=12)
+    assert np.array_equal(_num_nodes_per_bfs_layer(pos), expected_nodes_per_layer)
+    # Starting in the center of the bar, expect layers to be symmetric
+    pos = nx.bfs_layout(G, start=6)
+    # Expected layers: {6 (start)}, {5, 7}, {4, 8}, {8 nodes from remainder of bells}
+    expected_nodes_per_layer = [1, 2, 2, 8]
+    assert np.array_equal(_num_nodes_per_bfs_layer(pos), expected_nodes_per_layer)
+
+
+def test_bfs_layout_disconnected():
+    G = nx.complete_graph(5)
+    G.add_edges_from([(10, 11), (11, 12)])
+    with pytest.raises(nx.NetworkXError, match="bfs_layout didn't include all nodes"):
+        nx.bfs_layout(G, start=0)

From d70904954942d170b6468b2c6b1ff3d6308b3fcb Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Thu, 15 Feb 2024 07:34:57 -0600
Subject: [PATCH 075/129] Add `max_level=` argument to `louvain_communities` to
 limit macro-iterations (#6909)

* Add `max_level=` argument to `louvain_communities` to limit macro-iterations

* ...or None

* Add docstring and update variable names
---
 networkx/algorithms/community/louvain.py      | 19 +++++++++++++-----
 .../community/tests/test_louvain.py           | 20 +++++++++++++++++++
 2 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/networkx/algorithms/community/louvain.py b/networkx/algorithms/community/louvain.py
index 0c880532b9d..959c93a5104 100644
--- a/networkx/algorithms/community/louvain.py
+++ b/networkx/algorithms/community/louvain.py
@@ -1,6 +1,7 @@
 """Function for detecting communities based on Louvain Community Detection
 Algorithm"""
 
+import itertools
 from collections import defaultdict, deque
 
 import networkx as nx
@@ -13,7 +14,7 @@
 @py_random_state("seed")
 @nx._dispatchable(edge_attrs="weight")
 def louvain_communities(
-    G, weight="weight", resolution=1, threshold=0.0000001, seed=None
+    G, weight="weight", resolution=1, threshold=0.0000001, max_level=None, seed=None
 ):
     r"""Find the best partition of a graph using the Louvain Community Detection
     Algorithm.
@@ -56,7 +57,7 @@ def louvain_communities(
     increased modularity.
 
     The above two phases are executed until no modularity gain is achieved (or is less than
-    the `threshold`).
+    the `threshold`, or until `max_levels` is reached).
 
     Be careful with self-loops in the input graph. These are treated as
     previously reduced communities -- as if the process had been started
@@ -79,6 +80,10 @@ def louvain_communities(
         Modularity gain threshold for each level. If the gain of modularity
         between 2 levels of the algorithm is less than the given threshold
         then the algorithm stops and returns the resulting communities.
+    max_level : int or None, optional (default=None)
+        The maximum number of levels (steps of the algorithm) to compute.
+        Must be a positive integer or None. If None, then there is no max
+        level and the threshold parameter determines the stopping condition.
     seed : integer, random_state, or None (default)
         Indicator of random number generation state.
         See :ref:`Randomness<randomness>`.
@@ -115,9 +120,13 @@ def louvain_communities(
     louvain_partitions
     """
 
-    d = louvain_partitions(G, weight, resolution, threshold, seed)
-    q = deque(d, maxlen=1)
-    return q.pop()
+    partitions = louvain_partitions(G, weight, resolution, threshold, seed)
+    if max_level is not None:
+        if max_level <= 0:
+            raise ValueError("max_level argument must be a positive integer or None")
+        partitions = itertools.islice(partitions, max_level)
+    final_partition = deque(partitions, maxlen=1)
+    return final_partition.pop()
 
 
 @py_random_state("seed")
diff --git a/networkx/algorithms/community/tests/test_louvain.py b/networkx/algorithms/community/tests/test_louvain.py
index 60b95d37783..b47fb74c57e 100644
--- a/networkx/algorithms/community/tests/test_louvain.py
+++ b/networkx/algorithms/community/tests/test_louvain.py
@@ -1,3 +1,5 @@
+import pytest
+
 import networkx as nx
 
 
@@ -242,3 +244,21 @@ def test_empty_graph():
     G.add_nodes_from(range(5))
     expected = [{0}, {1}, {2}, {3}, {4}]
     assert nx.community.louvain_communities(G) == expected
+
+
+def test_max_level():
+    G = nx.LFR_benchmark_graph(
+        250, 3, 1.5, 0.009, average_degree=5, min_community=20, seed=10
+    )
+    parts_iter = nx.community.louvain_partitions(G, seed=42)
+    for max_level, expected in enumerate(parts_iter, 1):
+        partition = nx.community.louvain_communities(G, max_level=max_level, seed=42)
+        assert partition == expected
+    assert max_level > 1  # Ensure we are actually testing max_level
+    # max_level is an upper limit; it's okay if we stop before it's hit.
+    partition = nx.community.louvain_communities(G, max_level=max_level + 1, seed=42)
+    assert partition == expected
+    with pytest.raises(
+        ValueError, match="max_level argument must be a positive integer"
+    ):
+        nx.community.louvain_communities(G, max_level=0)

From 0ed564b4a9969278581b43dcc17c0d6eb1a93e81 Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Sun, 18 Feb 2024 10:13:30 -0600
Subject: [PATCH 076/129] Review and update `@nx._dispatchable` usage since
 3.2.1 (#7302)

* Review and update `@nx._dispatchable` usage since 3.2.1

* Also handle `np.random.Generator`
---
 examples/algorithms/plot_greedy_coloring.py |  2 +-
 networkx/algorithms/community/divisive.py   |  2 ++
 networkx/algorithms/operators/product.py    |  2 +-
 networkx/algorithms/tournament.py           |  2 +-
 networkx/algorithms/wiener.py               |  2 ++
 networkx/generators/expanders.py            | 16 +++++++++++++---
 networkx/utils/backends.py                  |  6 ++++--
 7 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/examples/algorithms/plot_greedy_coloring.py b/examples/algorithms/plot_greedy_coloring.py
index 93a7f4d2974..85ec0a07346 100644
--- a/examples/algorithms/plot_greedy_coloring.py
+++ b/examples/algorithms/plot_greedy_coloring.py
@@ -3,7 +3,7 @@
 Greedy Coloring
 ===============
 
-We attempt to color a graph using as few colors as possible, where no neighbours
+We attempt to color a graph using as few colors as possible, where no neighbors
 of a node can have same color as the node itself.
 """
 import numpy as np
diff --git a/networkx/algorithms/community/divisive.py b/networkx/algorithms/community/divisive.py
index 7dbf70ca3fd..1fc39594693 100644
--- a/networkx/algorithms/community/divisive.py
+++ b/networkx/algorithms/community/divisive.py
@@ -8,6 +8,7 @@
 ]
 
 
+@nx._dispatchable(edge_attrs="weight")
 def edge_betweenness_partition(G, number_of_sets, *, weight=None):
     """Partition created by iteratively removing the highest edge betweenness edge.
 
@@ -83,6 +84,7 @@ def edge_betweenness_partition(G, number_of_sets, *, weight=None):
     return partition
 
 
+@nx._dispatchable(edge_attrs="weight")
 def edge_current_flow_betweenness_partition(G, number_of_sets, *, weight=None):
     """Partition created by removing the highest edge current flow betweenness edge.
 
diff --git a/networkx/algorithms/operators/product.py b/networkx/algorithms/operators/product.py
index f7f1a4794f6..07bebdaa4b4 100644
--- a/networkx/algorithms/operators/product.py
+++ b/networkx/algorithms/operators/product.py
@@ -535,7 +535,7 @@ def corona_product(G, H):
     return GH
 
 
-@nx._dispatchable(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H, preserve_edge_attrs=True, preserve_node_attrs=True)
 def modular_product(G, H):
     r"""Returns the Modular product of G and H.
 
diff --git a/networkx/algorithms/tournament.py b/networkx/algorithms/tournament.py
index 6946afec799..3cf655f40ff 100644
--- a/networkx/algorithms/tournament.py
+++ b/networkx/algorithms/tournament.py
@@ -217,7 +217,7 @@ def score_sequence(G):
 
 @not_implemented_for("undirected")
 @not_implemented_for("multigraph")
-@nx._dispatchable
+@nx._dispatchable(preserve_edge_attrs={"G": {"weight": 1}})
 def tournament_matrix(G):
     r"""Returns the tournament matrix for the given tournament graph.
 
diff --git a/networkx/algorithms/wiener.py b/networkx/algorithms/wiener.py
index 471f8df0cf6..cb55d609f7d 100644
--- a/networkx/algorithms/wiener.py
+++ b/networkx/algorithms/wiener.py
@@ -94,6 +94,7 @@ def wiener_index(G, weight=None):
 
 @nx.utils.not_implemented_for("directed")
 @nx.utils.not_implemented_for("multigraph")
+@nx._dispatchable(edge_attrs="weight")
 def schultz_index(G, weight=None):
     r"""Returns the Schultz Index (of the first kind) of `G`
 
@@ -161,6 +162,7 @@ def schultz_index(G, weight=None):
 
 @nx.utils.not_implemented_for("directed")
 @nx.utils.not_implemented_for("multigraph")
+@nx._dispatchable(edge_attrs="weight")
 def gutman_index(G, weight=None):
     r"""Returns the Gutman Index for the graph `G`.
 
diff --git a/networkx/generators/expanders.py b/networkx/generators/expanders.py
index 33522ef550f..cc03500a470 100644
--- a/networkx/generators/expanders.py
+++ b/networkx/generators/expanders.py
@@ -214,6 +214,7 @@ def paley_graph(p, create_using=None):
 
 
 @nx.utils.decorators.np_random_state("seed")
+@nx._dispatchable(graphs=None)
 def maybe_regular_expander(n, d, *, create_using=None, max_tries=100, seed=None):
     r"""Utility for creating a random regular expander.
 
@@ -330,6 +331,7 @@ def maybe_regular_expander(n, d, *, create_using=None, max_tries=100, seed=None)
 
 @nx.utils.not_implemented_for("directed")
 @nx.utils.not_implemented_for("multigraph")
+@nx._dispatchable(preserve_edge_attrs={"G": {"weight": 1}})
 def is_regular_expander(G, *, epsilon=0):
     r"""Determines whether the graph G is a regular expander. [1]_
 
@@ -396,7 +398,11 @@ def is_regular_expander(G, *, epsilon=0):
     return abs(lambda2) < 2 ** np.sqrt(d - 1) + epsilon
 
 
-def random_regular_expander_graph(n, d, *, epsilon=0, create_using=None, max_tries=100):
+@nx.utils.decorators.np_random_state("seed")
+@nx._dispatchable(graphs=None)
+def random_regular_expander_graph(
+    n, d, *, epsilon=0, create_using=None, max_tries=100, seed=None
+):
     r"""Returns a random regular expander graph on $n$ nodes with degree $d$.
 
     An expander graph is a sparse graph with strong connectivity properties. [1]_
@@ -417,6 +423,8 @@ def random_regular_expander_graph(n, d, *, epsilon=0, create_using=None, max_tri
     epsilon : int, float, default=0
     max_tries : int, (default: 100)
       The number of allowed loops, also used in the maybe_regular_expander utility
+    seed : (default: None)
+      Seed used to set random number generation state. See :ref`Randomness<randomness>`.
 
     Raises
     ------
@@ -446,13 +454,15 @@ def random_regular_expander_graph(n, d, *, epsilon=0, create_using=None, max_tri
     .. [3] Ramanujan graphs, https://en.wikipedia.org/wiki/Ramanujan_graph
 
     """
-    G = maybe_regular_expander(n, d, create_using=create_using, max_tries=max_tries)
+    G = maybe_regular_expander(
+        n, d, create_using=create_using, max_tries=max_tries, seed=seed
+    )
     iterations = max_tries
 
     while not is_regular_expander(G, epsilon=epsilon):
         iterations -= 1
         G = maybe_regular_expander(
-            n=n, d=d, create_using=create_using, max_tries=max_tries
+            n=n, d=d, create_using=create_using, max_tries=max_tries, seed=seed
         )
 
         if iterations == 0:
diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 26cec6d2d83..73cf29469db 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -806,6 +806,8 @@ def _convert_and_call_for_tests(
         from itertools import tee
         from random import Random
 
+        from numpy.random import Generator, RandomState
+
         # We sometimes compare the backend result to the original result,
         # so we need two sets of arguments. We tee iterators and copy
         # random state so that they may be used twice.
@@ -815,7 +817,7 @@ def _convert_and_call_for_tests(
             args1, args2 = zip(
                 *(
                     (arg, copy(arg))
-                    if isinstance(arg, Random | BytesIO)
+                    if isinstance(arg, BytesIO | Random | Generator | RandomState)
                     else tee(arg)
                     if isinstance(arg, Iterator) and not isinstance(arg, BufferedReader)
                     else (arg, arg)
@@ -828,7 +830,7 @@ def _convert_and_call_for_tests(
             kwargs1, kwargs2 = zip(
                 *(
                     ((k, v), (k, copy(v)))
-                    if isinstance(v, Random | BytesIO)
+                    if isinstance(v, BytesIO | Random | Generator | RandomState)
                     else ((k, (teed := tee(v))[0]), (k, teed[1]))
                     if isinstance(v, Iterator) and not isinstance(v, BufferedReader)
                     else ((k, v), (k, v))

From 88193c0f566a42482983d1b67df174378d642bda Mon Sep 17 00:00:00 2001
From: Vanshika Mishra <74042272+vanshika230@users.noreply.github.com>
Date: Thu, 22 Feb 2024 02:24:20 +0530
Subject: [PATCH 077/129] Improve test coverage for bipartite extendability
 (#7306)

* Improve testcov for bipextendability

* change function name

* changing fnx name
---
 networkx/algorithms/bipartite/tests/test_extendability.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/networkx/algorithms/bipartite/tests/test_extendability.py b/networkx/algorithms/bipartite/tests/test_extendability.py
index d7ae34e4c1b..17b7124341b 100644
--- a/networkx/algorithms/bipartite/tests/test_extendability.py
+++ b/networkx/algorithms/bipartite/tests/test_extendability.py
@@ -29,6 +29,14 @@ def test_no_perfect_matching_raises():
         nx.bipartite.maximal_extendability(G)
 
 
+def test_residual_graph_not_strongly_connected_raises():
+    G = nx.Graph([(1, 2), (2, 3), (3, 4)])
+    with pytest.raises(
+        nx.NetworkXError, match="The residual graph of G is not strongly connected"
+    ):
+        nx.bipartite.maximal_extendability(G)
+
+
 def test_ladder_graph_is_1():
     G = nx.ladder_graph(3)
     assert nx.bipartite.maximal_extendability(G) == 1

From b7782faa065834b9151caaed63653807fc5ab826 Mon Sep 17 00:00:00 2001
From: Matthew Feickert <matthew.feickert@cern.ch>
Date: Wed, 21 Feb 2024 22:46:12 -0600
Subject: [PATCH 078/129] CI: Update scientific-python/upload-nightly-action
 from 0.3.0 to 0.4.0 (#7309)

* Update the scientific-python/upload-nightly-action to v0.4.0 to avoid issues
  with uploading wheels of the same name to Anaconda Cloud where the project
  being uploaded to only contains one wheel (the one being replaced).
   - c.f. https://github.com/scientific-python/upload-nightly-action/releases/tag/0.4.0
---
 .github/workflows/nightly.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index a8bc0c0575f..a8010ade75e 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -27,7 +27,7 @@ jobs:
       - name: List contents of wheel
         run: python -m zipfile --list dist/networkx-*.whl
       - name: Upload nighlty wheel
-        uses: scientific-python/upload-nightly-action@6e9304f7a3a5501c6f98351537493ec898728299 # 0.3.0
+        uses: scientific-python/upload-nightly-action@95f7bf6a22281b8072fae929429dd0408f09ea63 # 0.4.0
         with:
           anaconda_nightly_upload_token: ${{ secrets.ANACONDA_NIGHTLY }}
           artifacts_path: dist/

From 8cffd1e7004a94be4556121cc3aff442772542d0 Mon Sep 17 00:00:00 2001
From: Matthew Feickert <matthew.feickert@cern.ch>
Date: Thu, 22 Feb 2024 11:28:22 -0600
Subject: [PATCH 079/129] CI: Group dependabot updates (#7308)

* Group dependabot updates to reduce the number of PRs.
   - c.f. sp-repo-review GH212: Require GHA update grouping
     https://learn.scientific-python.org/development/guides/gha-basic/#GH212
---
 .github/dependabot.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 76c0f80b78a..ec68dc5ee50 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -4,6 +4,10 @@ updates:
     directory: "/"
     schedule:
       interval: "monthly"
+    groups:
+      actions:
+        patterns:
+          - "*"
     labels:
       - "type: Maintenance"
   - package-ecosystem: "pip"

From eec4012d14ec04467f13712b55ea03be53718136 Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Fri, 23 Feb 2024 13:42:39 -0600
Subject: [PATCH 080/129] Transmogrify `_dispatchable` objects into functions
 (#7298)

* Transmogrify `_dispatchable` objects into functions

* fix?
---
 networkx/classes/tests/test_backends.py | 14 +++++++++++++-
 networkx/utils/backends.py              | 10 ++++++++++
 networkx/utils/decorators.py            |  8 +++++++-
 3 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/networkx/classes/tests/test_backends.py b/networkx/classes/tests/test_backends.py
index e1a7c1cf6ff..cc171cf5be1 100644
--- a/networkx/classes/tests/test_backends.py
+++ b/networkx/classes/tests/test_backends.py
@@ -17,8 +17,16 @@ def test_dispatch_kwds_vs_args():
 
 
 def test_pickle():
+    count = 0
     for name, func in nx.utils.backends._registered_algorithms.items():
-        assert pickle.loads(pickle.dumps(func)) is func
+        try:
+            # Some functions can't be pickled, but it's not b/c of _dispatchable
+            pickled = pickle.dumps(func)
+        except pickle.PicklingError:
+            continue
+        assert pickle.loads(pickled) is func
+        count += 1
+    assert count > 0
     assert pickle.loads(pickle.dumps(nx.inverse_line_graph)) is nx.inverse_line_graph
 
 
@@ -74,3 +82,7 @@ def convert_to_nx(obj, *, name=None):
         del LoopbackDispatcher.from_scipy_sparse_array
     with pytest.raises(ImportError, match="Unable to load"):
         nx.from_scipy_sparse_array(A, backend="bad-backend-name")
+
+
+def test_dispatchable_are_functions():
+    assert type(nx.pagerank) is type(nx.pagerank.orig_func)
diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 73cf29469db..d1491f51078 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -94,10 +94,15 @@ class WrappedSparse:
 import networkx as nx
 
 from ..exception import NetworkXNotImplemented
+from .decorators import argmap
 
 __all__ = ["_dispatchable"]
 
 
+def _do_nothing():
+    """This does nothing at all, yet it helps turn `_dispatchable` into functions."""
+
+
 def _get_backends(group, *, load_and_call=False):
     items = entry_points(group=group)
     rv = {}
@@ -348,6 +353,11 @@ def __new__(
             raise KeyError(
                 f"Algorithm already exists in dispatch registry: {name}"
             ) from None
+        # Use the magic of `argmap` to turn `self` into a function. This does result
+        # in small additional overhead compared to calling `_dispatchable` directly,
+        # but `argmap` has the magical property that it can stack with other `argmap`
+        # decorators "for free". Being a function is better for REPRs and type-checkers.
+        self = argmap(_do_nothing)(self)
         _registered_algorithms[name] = self
         return self
 
diff --git a/networkx/utils/decorators.py b/networkx/utils/decorators.py
index e986434bd43..ea37a506e19 100644
--- a/networkx/utils/decorators.py
+++ b/networkx/utils/decorators.py
@@ -1107,7 +1107,13 @@ def signature(cls, f):
             if prev == param.POSITIONAL_ONLY != kind:
                 # the last token was position-only, but this one isn't
                 def_sig.append("/")
-            if prev != param.KEYWORD_ONLY == kind != param.VAR_POSITIONAL:
+            if (
+                param.VAR_POSITIONAL
+                != prev
+                != param.KEYWORD_ONLY
+                == kind
+                != param.VAR_POSITIONAL
+            ):
                 # param is the first keyword-only arg and isn't starred
                 def_sig.append("*")
 

From 26ccbd7090265b0ad6f89a6edb96c873e90b419c Mon Sep 17 00:00:00 2001
From: Mridul Seth <seth.mridul@gmail.com>
Date: Sat, 24 Feb 2024 11:19:35 +0530
Subject: [PATCH 081/129] CI: update upload-nightly-action to 0.5.0 (#7311)

---
 .github/workflows/nightly.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index a8010ade75e..ee854c0045f 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -27,7 +27,7 @@ jobs:
       - name: List contents of wheel
         run: python -m zipfile --list dist/networkx-*.whl
       - name: Upload nighlty wheel
-        uses: scientific-python/upload-nightly-action@95f7bf6a22281b8072fae929429dd0408f09ea63 # 0.4.0
+        uses: scientific-python/upload-nightly-action@b67d7fcc0396e1128a474d1ab2b48aa94680f9fc # 0.5.0
         with:
           anaconda_nightly_upload_token: ${{ secrets.ANACONDA_NIGHTLY }}
           artifacts_path: dist/

From de85e3fe52879f819e7a7924474fc6be3994e8e4 Mon Sep 17 00:00:00 2001
From: Aditi Juneja <91629733+Schefflera-Arboricola@users.noreply.github.com>
Date: Sun, 25 Feb 2024 07:25:18 +0530
Subject: [PATCH 082/129] renaming backend `func_info` dictionary's keys
 (#7219)

* renamed extra_parameters to additional_parameters

* renamed extra_docstring to backend_func_docs

* added backend_func_examples and backend_func_url

* added example heading

* small edit

* style fix

* bug fix

* updated backends.py

* style fix

* code refactoring

* style fix

* Update backends.py

* updated lines

* rm backend_func_examples

* using walrus operator instead of 'if'

by @eriknw

Co-authored-by: Erik Welch <erik.n.welch@gmail.com>

* used walrus operator

* style fix

* used walrus opr

* style fix

* style fix

* Updated key names

* Updated comment

---------

Co-authored-by: Erik Welch <erik.n.welch@gmail.com>
---
 networkx/utils/backends.py | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index d1491f51078..8dfb82496de 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -86,7 +86,6 @@ class WrappedSparse:
 """
 import inspect
 import os
-import sys
 import warnings
 from functools import partial
 from importlib.metadata import entry_points
@@ -972,19 +971,26 @@ def _make_doc(self):
                 continue
 
             func_info = info["functions"][self.name]
-            if "extra_docstring" in func_info:
+
+            # Renaming extra_docstring to additional_docs
+            if func_docs := (
+                func_info.get("additional_docs") or func_info.get("extra_docstring")
+            ):
                 lines.extend(
-                    f"  {line}" if line else line
-                    for line in func_info["extra_docstring"].split("\n")
+                    f"  {line}" if line else line for line in func_docs.split("\n")
                 )
                 add_gap = True
             else:
                 add_gap = False
-            if "extra_parameters" in func_info:
+
+            # Renaming extra_parameters to additional_parameters
+            if extra_parameters := (
+                func_info.get("extra_parameters")
+                or func_info.get("additional_parameters")
+            ):
                 if add_gap:
                     lines.append("")
-                lines.append("  Extra parameters:")
-                extra_parameters = func_info["extra_parameters"]
+                lines.append("  Additional parameters:")
                 for param in sorted(extra_parameters):
                     lines.append(f"    {param}")
                     if desc := extra_parameters[param]:
@@ -993,6 +999,10 @@ def _make_doc(self):
             else:
                 lines.append("")
 
+            if func_url := func_info.get("url"):
+                lines.append(f"[`Source <{func_url}>`_]")
+                lines.append("")
+
         lines.pop()  # Remove last empty line
         to_add = "\n    ".join(lines)
         return f"{self._orig_doc.rstrip()}\n\n    {to_add}"

From 5b9aec5bae22608e6879bebdaa1be6a59315e95b Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Wed, 28 Feb 2024 08:49:54 -0600
Subject: [PATCH 083/129] Add `mutates_input=` and `returns_graph=` to
 `_dispatchable` (#7191)

* Add `mutates_input=True` to `_dispatch`

* Add `returns_graph=True` to `_dispatchable`

* Don't auto-convert for functions that return Graphs; also, updates

* more comments

* Make `returns_graph` attribute private (for now)
---
 .../algorithms/approximation/steinertree.py   |   4 +-
 .../approximation/traveling_salesman.py       |   2 +-
 .../algorithms/approximation/treewidth.py     |   6 +-
 networkx/algorithms/bipartite/edgelist.py     |   4 +-
 networkx/algorithms/bipartite/generators.py   |  16 +--
 networkx/algorithms/bipartite/matrix.py       |   2 +-
 networkx/algorithms/bipartite/projection.py   |  12 +-
 networkx/algorithms/centrality/closeness.py   |   2 +-
 networkx/algorithms/chordal.py                |   2 +-
 networkx/algorithms/clique.py                 |   4 +-
 .../algorithms/coloring/equitable_coloring.py |   2 +-
 .../components/strongly_connected.py          |   2 +-
 .../connectivity/edge_augmentation.py         |   2 +-
 .../connectivity/edge_kcomponents.py          |   2 +-
 networkx/algorithms/connectivity/utils.py     |   4 +-
 networkx/algorithms/core.py                   |  10 +-
 networkx/algorithms/dag.py                    |   8 +-
 networkx/algorithms/distance_measures.py      |   2 +-
 networkx/algorithms/euler.py                  |   2 +-
 networkx/algorithms/flow/boykovkolmogorov.py  |   1 +
 networkx/algorithms/flow/dinitz_alg.py        |   1 +
 networkx/algorithms/flow/edmondskarp.py       |   2 +
 networkx/algorithms/flow/gomory_hu.py         |   2 +-
 networkx/algorithms/flow/preflowpush.py       |   1 +
 .../algorithms/flow/shortestaugmentingpath.py |   1 +
 networkx/algorithms/flow/utils.py             |   2 +-
 networkx/algorithms/hybrid.py                 |   2 +-
 .../isomorphism/tree_isomorphism.py           |   2 +-
 networkx/algorithms/minors/contraction.py     |  10 +-
 networkx/algorithms/moral.py                  |   2 +-
 networkx/algorithms/operators/all.py          |   8 +-
 networkx/algorithms/operators/binary.py       |  14 +--
 networkx/algorithms/operators/product.py      |  18 +--
 networkx/algorithms/operators/unary.py        |   4 +-
 networkx/algorithms/planarity.py              |   8 +-
 networkx/algorithms/regular.py                |   2 +-
 networkx/algorithms/smallworld.py             |   4 +-
 networkx/algorithms/sparsifiers.py            |   2 +-
 networkx/algorithms/summarization.py          |   6 +-
 networkx/algorithms/swap.py                   |   6 +-
 networkx/algorithms/threshold.py              |   4 +-
 networkx/algorithms/tournament.py             |   2 +-
 .../traversal/breadth_first_search.py         |   2 +-
 .../traversal/depth_first_search.py           |   2 +-
 networkx/algorithms/tree/branchings.py        |   7 +-
 networkx/algorithms/tree/coding.py            |   4 +-
 networkx/algorithms/tree/decomposition.py     |   2 +-
 networkx/algorithms/tree/mst.py               |   8 +-
 networkx/algorithms/tree/operations.py        |   2 +-
 networkx/algorithms/triads.py                 |   4 +-
 networkx/convert.py                           |   6 +-
 networkx/convert_matrix.py                    |   8 +-
 networkx/drawing/nx_agraph.py                 |   4 +-
 networkx/drawing/nx_pydot.py                  |   4 +-
 networkx/generators/atlas.py                  |   4 +-
 networkx/generators/classic.py                |  42 +++----
 networkx/generators/cographs.py               |   2 +-
 networkx/generators/community.py              |  20 ++--
 networkx/generators/degree_seq.py             |  14 +--
 networkx/generators/directed.py               |  12 +-
 networkx/generators/duplication.py            |   4 +-
 networkx/generators/ego.py                    |   2 +-
 networkx/generators/expanders.py              |  10 +-
 networkx/generators/geometric.py              |  14 +--
 networkx/generators/harary_graph.py           |   4 +-
 networkx/generators/internet_as_graphs.py     |   2 +-
 networkx/generators/intersection.py           |   6 +-
 networkx/generators/interval_graph.py         |   2 +-
 networkx/generators/joint_degree_seq.py       |   4 +-
 networkx/generators/lattice.py                |  10 +-
 networkx/generators/line.py                   |   4 +-
 networkx/generators/mycielski.py              |   4 +-
 networkx/generators/nonisomorphic_trees.py    |   2 +-
 networkx/generators/random_clustered.py       |   2 +-
 networkx/generators/random_graphs.py          |  32 ++---
 networkx/generators/small.py                  |  46 +++----
 networkx/generators/social.py                 |   8 +-
 networkx/generators/spectral_graph_forge.py   |   2 +-
 networkx/generators/stochastic.py             |   4 +-
 networkx/generators/sudoku.py                 |   2 +-
 networkx/generators/time_series.py            |   2 +-
 networkx/generators/trees.py                  |  18 +--
 networkx/generators/triads.py                 |   2 +-
 networkx/readwrite/adjlist.py                 |   4 +-
 networkx/readwrite/edgelist.py                |   6 +-
 networkx/readwrite/gexf.py                    |   2 +-
 networkx/readwrite/gml.py                     |   4 +-
 networkx/readwrite/graph6.py                  |   4 +-
 networkx/readwrite/graphml.py                 |   4 +-
 networkx/readwrite/json_graph/adjacency.py    |   2 +-
 networkx/readwrite/json_graph/cytoscape.py    |   2 +-
 networkx/readwrite/json_graph/node_link.py    |   2 +-
 networkx/readwrite/json_graph/tree.py         |   2 +-
 networkx/readwrite/leda.py                    |   4 +-
 networkx/readwrite/multiline_adjlist.py       |   4 +-
 networkx/readwrite/p2g.py                     |   4 +-
 networkx/readwrite/pajek.py                   |   4 +-
 networkx/readwrite/sparse6.py                 |   4 +-
 networkx/relabel.py                           |   8 +-
 networkx/utils/backends.py                    | 113 ++++++++++++++++--
 100 files changed, 405 insertions(+), 293 deletions(-)

diff --git a/networkx/algorithms/approximation/steinertree.py b/networkx/algorithms/approximation/steinertree.py
index 7751251ddf8..af5916442b9 100644
--- a/networkx/algorithms/approximation/steinertree.py
+++ b/networkx/algorithms/approximation/steinertree.py
@@ -7,7 +7,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatchable(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight", returns_graph=True)
 def metric_closure(G, weight="weight"):
     """Return the metric closure of a graph.
 
@@ -126,7 +126,7 @@ def _remove_nonterminal_leaves(G, terminals):
 
 
 @not_implemented_for("directed")
-@nx._dispatchable(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight", returns_graph=True)
 def steiner_tree(G, terminal_nodes, weight="weight", method=None):
     r"""Return an approximation to the minimum Steiner tree of a graph.
 
diff --git a/networkx/algorithms/approximation/traveling_salesman.py b/networkx/algorithms/approximation/traveling_salesman.py
index f2127e3066c..f3fae97e8ef 100644
--- a/networkx/algorithms/approximation/traveling_salesman.py
+++ b/networkx/algorithms/approximation/traveling_salesman.py
@@ -492,7 +492,7 @@ def asadpour_atsp(G, weight="weight", seed=None, source=None):
     return _shortcutting(circuit)
 
 
-@nx._dispatchable(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight", returns_graph=True)
 def held_karp_ascent(G, weight="weight"):
     """
     Minimizes the Held-Karp relaxation of the TSP for `G`
diff --git a/networkx/algorithms/approximation/treewidth.py b/networkx/algorithms/approximation/treewidth.py
index c7c01a1cd4d..31d73f63682 100644
--- a/networkx/algorithms/approximation/treewidth.py
+++ b/networkx/algorithms/approximation/treewidth.py
@@ -41,7 +41,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def treewidth_min_degree(G):
     """Returns a treewidth decomposition using the Minimum Degree heuristic.
 
@@ -65,7 +65,7 @@ def treewidth_min_degree(G):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def treewidth_min_fill_in(G):
     """Returns a treewidth decomposition using the Minimum Fill-in heuristic.
 
@@ -177,7 +177,7 @@ def min_fill_in_heuristic(graph):
     return min_fill_in_node
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def treewidth_decomp(G, heuristic=min_fill_in_heuristic):
     """Returns a treewidth decomposition using the passed heuristic.
 
diff --git a/networkx/algorithms/bipartite/edgelist.py b/networkx/algorithms/bipartite/edgelist.py
index b9b2a82e05a..70631ea0e09 100644
--- a/networkx/algorithms/bipartite/edgelist.py
+++ b/networkx/algorithms/bipartite/edgelist.py
@@ -146,7 +146,7 @@ def generate_edgelist(G, delimiter=" ", data=True):
                 yield delimiter.join(map(str, edge))
 
 
-@nx._dispatchable(name="bipartite_parse_edgelist", graphs=None)
+@nx._dispatchable(name="bipartite_parse_edgelist", graphs=None, returns_graph=True)
 def parse_edgelist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
 ):
@@ -268,7 +268,7 @@ def parse_edgelist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(name="bipartite_read_edgelist", graphs=None)
+@nx._dispatchable(name="bipartite_read_edgelist", graphs=None, returns_graph=True)
 def read_edgelist(
     path,
     comments="#",
diff --git a/networkx/algorithms/bipartite/generators.py b/networkx/algorithms/bipartite/generators.py
index 2774c6fd409..de6f0797239 100644
--- a/networkx/algorithms/bipartite/generators.py
+++ b/networkx/algorithms/bipartite/generators.py
@@ -20,7 +20,7 @@
 ]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number([0, 1])
 def complete_bipartite_graph(n1, n2, create_using=None):
     """Returns the complete bipartite graph `K_{n_1,n_2}`.
@@ -67,7 +67,7 @@ def complete_bipartite_graph(n1, n2, create_using=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(name="bipartite_configuration_model", graphs=None)
+@nx._dispatchable(name="bipartite_configuration_model", graphs=None, returns_graph=True)
 def configuration_model(aseq, bseq, create_using=None, seed=None):
     """Returns a random bipartite graph from two given degree sequences.
 
@@ -138,7 +138,7 @@ def configuration_model(aseq, bseq, create_using=None, seed=None):
     return G
 
 
-@nx._dispatchable(name="bipartite_havel_hakimi_graph", graphs=None)
+@nx._dispatchable(name="bipartite_havel_hakimi_graph", graphs=None, returns_graph=True)
 def havel_hakimi_graph(aseq, bseq, create_using=None):
     """Returns a bipartite graph from two given degree sequences using a
     Havel-Hakimi style construction.
@@ -213,7 +213,7 @@ def havel_hakimi_graph(aseq, bseq, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 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.
@@ -287,7 +287,7 @@ def reverse_havel_hakimi_graph(aseq, bseq, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 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.
@@ -366,7 +366,7 @@ def alternating_havel_hakimi_graph(aseq, bseq, create_using=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 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.
@@ -438,7 +438,7 @@ def preferential_attachment_graph(aseq, p, create_using=None, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_graph(n, m, p, seed=None, directed=False):
     """Returns a bipartite random graph.
 
@@ -525,7 +525,7 @@ def random_graph(n, m, p, seed=None, directed=False):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def gnmk_random_graph(n, m, k, seed=None, directed=False):
     """Returns a random bipartite graph G_{n,m,k}.
 
diff --git a/networkx/algorithms/bipartite/matrix.py b/networkx/algorithms/bipartite/matrix.py
index 8809e21b62e..462ef8a1311 100644
--- a/networkx/algorithms/bipartite/matrix.py
+++ b/networkx/algorithms/bipartite/matrix.py
@@ -110,7 +110,7 @@ def biadjacency_matrix(
         raise nx.NetworkXError(f"Unknown sparse array format: {format}") from err
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 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.
diff --git a/networkx/algorithms/bipartite/projection.py b/networkx/algorithms/bipartite/projection.py
index 55544c4acbc..1eb71fa528f 100644
--- a/networkx/algorithms/bipartite/projection.py
+++ b/networkx/algorithms/bipartite/projection.py
@@ -12,7 +12,9 @@
 ]
 
 
-@nx._dispatchable(graphs="B", preserve_node_attrs=True, preserve_graph_attrs=True)
+@nx._dispatchable(
+    graphs="B", preserve_node_attrs=True, preserve_graph_attrs=True, returns_graph=True
+)
 def projected_graph(B, nodes, multigraph=False):
     r"""Returns the projection of B onto one of its node sets.
 
@@ -117,7 +119,7 @@ def projected_graph(B, nodes, multigraph=False):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatchable(graphs="B")
+@nx._dispatchable(graphs="B", returns_graph=True)
 def weighted_projected_graph(B, nodes, ratio=False):
     r"""Returns a weighted projection of B onto one of its node sets.
 
@@ -218,7 +220,7 @@ def weighted_projected_graph(B, nodes, ratio=False):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatchable(graphs="B")
+@nx._dispatchable(graphs="B", returns_graph=True)
 def collaboration_weighted_projected_graph(B, nodes):
     r"""Newman's weighted projection of B onto one of its node sets.
 
@@ -312,7 +314,7 @@ def collaboration_weighted_projected_graph(B, nodes):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatchable(graphs="B")
+@nx._dispatchable(graphs="B", returns_graph=True)
 def overlap_weighted_projected_graph(B, nodes, jaccard=True):
     r"""Overlap weighted projection of B onto one of its node sets.
 
@@ -412,7 +414,7 @@ def overlap_weighted_projected_graph(B, nodes, jaccard=True):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatchable(graphs="B", preserve_all_attrs=True)
+@nx._dispatchable(graphs="B", preserve_all_attrs=True, returns_graph=True)
 def generic_weighted_projected_graph(B, nodes, weight_function=None):
     r"""Weighted projection of B with a user-specified weight function.
 
diff --git a/networkx/algorithms/centrality/closeness.py b/networkx/algorithms/centrality/closeness.py
index 3527c468f33..1c1722d4ed4 100644
--- a/networkx/algorithms/centrality/closeness.py
+++ b/networkx/algorithms/centrality/closeness.py
@@ -137,7 +137,7 @@ def closeness_centrality(G, u=None, distance=None, wf_improved=True):
 
 
 @not_implemented_for("directed")
-@nx._dispatchable
+@nx._dispatchable(mutates_input=True)
 def incremental_closeness_centrality(
     G, edge, prev_cc=None, insertion=True, wf_improved=True
 ):
diff --git a/networkx/algorithms/chordal.py b/networkx/algorithms/chordal.py
index 875bf24d14e..6bd3ccd2ea3 100644
--- a/networkx/algorithms/chordal.py
+++ b/networkx/algorithms/chordal.py
@@ -369,7 +369,7 @@ def _find_chordality_breaker(G, s=None, treewidth_bound=sys.maxsize):
 
 
 @not_implemented_for("directed")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def complete_to_chordal_graph(G):
     """Return a copy of G completed to a chordal graph
 
diff --git a/networkx/algorithms/clique.py b/networkx/algorithms/clique.py
index 0b4d156e900..5f959dd4658 100644
--- a/networkx/algorithms/clique.py
+++ b/networkx/algorithms/clique.py
@@ -412,7 +412,7 @@ def expand(subg, cand):
     return expand(subg_init, cand_init)
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def make_max_clique_graph(G, create_using=None):
     """Returns the maximal clique graph of the given graph.
 
@@ -460,7 +460,7 @@ def make_max_clique_graph(G, create_using=None):
     return B
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def make_clique_bipartite(G, fpos=None, create_using=None, name=None):
     """Returns the bipartite clique graph corresponding to `G`.
 
diff --git a/networkx/algorithms/coloring/equitable_coloring.py b/networkx/algorithms/coloring/equitable_coloring.py
index 659609664c1..e464a074470 100644
--- a/networkx/algorithms/coloring/equitable_coloring.py
+++ b/networkx/algorithms/coloring/equitable_coloring.py
@@ -112,7 +112,7 @@ def move_witnesses(src_color, dst_color, N, H, F, C, T_cal, L):
         X = Y
 
 
-@nx._dispatchable
+@nx._dispatchable(mutates_input=True)
 def pad_graph(G, num_colors):
     """Add a disconnected complete clique K_p such that the number of nodes in
     the graph becomes a multiple of `num_colors`.
diff --git a/networkx/algorithms/components/strongly_connected.py b/networkx/algorithms/components/strongly_connected.py
index 5f89cb1278c..febd1b9b541 100644
--- a/networkx/algorithms/components/strongly_connected.py
+++ b/networkx/algorithms/components/strongly_connected.py
@@ -346,7 +346,7 @@ def is_strongly_connected(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def condensation(G, scc=None):
     """Returns the condensation of G.
 
diff --git a/networkx/algorithms/connectivity/edge_augmentation.py b/networkx/algorithms/connectivity/edge_augmentation.py
index 0e77a0bf683..d095ed51917 100644
--- a/networkx/algorithms/connectivity/edge_augmentation.py
+++ b/networkx/algorithms/connectivity/edge_augmentation.py
@@ -1040,7 +1040,7 @@ def _minimum_rooted_branching(D, root):
     return A
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def collapse(G, grouped_nodes):
     """Collapses each group of nodes into a single node.
 
diff --git a/networkx/algorithms/connectivity/edge_kcomponents.py b/networkx/algorithms/connectivity/edge_kcomponents.py
index 9dcdf71a2e5..e071f4d3df8 100644
--- a/networkx/algorithms/connectivity/edge_kcomponents.py
+++ b/networkx/algorithms/connectivity/edge_kcomponents.py
@@ -503,7 +503,7 @@ def _high_degree_components(G, k):
         yield from nx.connected_components(H)
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def general_k_edge_subgraphs(G, k):
     """General algorithm to find all maximal k-edge-connected subgraphs in `G`.
 
diff --git a/networkx/algorithms/connectivity/utils.py b/networkx/algorithms/connectivity/utils.py
index cd3dadf61da..a4d822ae523 100644
--- a/networkx/algorithms/connectivity/utils.py
+++ b/networkx/algorithms/connectivity/utils.py
@@ -6,7 +6,7 @@
 __all__ = ["build_auxiliary_node_connectivity", "build_auxiliary_edge_connectivity"]
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def build_auxiliary_node_connectivity(G):
     r"""Creates a directed graph D from an undirected graph G to compute flow
     based node connectivity.
@@ -59,7 +59,7 @@ def build_auxiliary_node_connectivity(G):
     return H
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def build_auxiliary_edge_connectivity(G):
     """Auxiliary digraph for computing flow based edge connectivity
 
diff --git a/networkx/algorithms/core.py b/networkx/algorithms/core.py
index 7ab7598260c..511e6d9d0ba 100644
--- a/networkx/algorithms/core.py
+++ b/networkx/algorithms/core.py
@@ -148,7 +148,7 @@ def _core_subgraph(G, k_filter, k=None, core=None):
     return G.subgraph(nodes).copy()
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def k_core(G, k=None, core_number=None):
     """Returns the k-core of G.
 
@@ -224,7 +224,7 @@ def k_filter(v, k, c):
     return _core_subgraph(G, k_filter, k, core_number)
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def k_shell(G, k=None, core_number=None):
     """Returns the k-shell of G.
 
@@ -306,7 +306,7 @@ def k_filter(v, k, c):
     return _core_subgraph(G, k_filter, k, core_number)
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def k_crust(G, k=None, core_number=None):
     """Returns the k-crust of G.
 
@@ -389,7 +389,7 @@ def k_crust(G, k=None, core_number=None):
     return G.subgraph(nodes).copy()
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def k_corona(G, k, core_number=None):
     """Returns the k-corona of G.
 
@@ -468,7 +468,7 @@ def func(v, k, c):
 
 @nx.utils.not_implemented_for("directed")
 @nx.utils.not_implemented_for("multigraph")
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def k_truss(G, k):
     """Returns the k-truss of `G`.
 
diff --git a/networkx/algorithms/dag.py b/networkx/algorithms/dag.py
index 04c76424feb..a70e2c5efaf 100644
--- a/networkx/algorithms/dag.py
+++ b/networkx/algorithms/dag.py
@@ -665,7 +665,7 @@ def is_aperiodic(G):
         return g == 1 and nx.is_aperiodic(G.subgraph(set(G) - set(levels)))
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def transitive_closure(G, reflexive=False):
     """Returns transitive closure of a graph
 
@@ -758,7 +758,7 @@ def transitive_closure(G, reflexive=False):
 
 
 @not_implemented_for("undirected")
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def transitive_closure_dag(G, topo_order=None):
     """Returns the transitive closure of a directed acyclic graph.
 
@@ -815,7 +815,7 @@ def transitive_closure_dag(G, topo_order=None):
 
 
 @not_implemented_for("undirected")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def transitive_reduction(G):
     """Returns transitive reduction of a directed graph
 
@@ -1124,7 +1124,7 @@ def root_to_leaf_paths(G):
 
 @not_implemented_for("multigraph")
 @not_implemented_for("undirected")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def dag_to_branching(G):
     """Returns a branching representing all (overlapping) paths from
     root nodes to leaf nodes in the given directed acyclic graph.
diff --git a/networkx/algorithms/distance_measures.py b/networkx/algorithms/distance_measures.py
index 423d9b6dee5..310c3913f01 100644
--- a/networkx/algorithms/distance_measures.py
+++ b/networkx/algorithms/distance_measures.py
@@ -553,7 +553,7 @@ def center(G, e=None, usebounds=False, weight=None):
     return p
 
 
-@nx._dispatchable(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight", mutates_input={"attr": 2})
 def barycenter(G, weight=None, attr=None, sp=None):
     r"""Calculate barycenter of a connected graph, optionally with edge weights.
 
diff --git a/networkx/algorithms/euler.py b/networkx/algorithms/euler.py
index 54ab9bcff09..2e0e57358aa 100644
--- a/networkx/algorithms/euler.py
+++ b/networkx/algorithms/euler.py
@@ -386,7 +386,7 @@ def eulerian_path(G, source=None, keys=False):
 
 
 @not_implemented_for("directed")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def eulerize(G):
     """Transforms a graph into an Eulerian graph.
 
diff --git a/networkx/algorithms/flow/boykovkolmogorov.py b/networkx/algorithms/flow/boykovkolmogorov.py
index c75bbba69ca..e1c9486f527 100644
--- a/networkx/algorithms/flow/boykovkolmogorov.py
+++ b/networkx/algorithms/flow/boykovkolmogorov.py
@@ -15,6 +15,7 @@
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_graph_attrs={"residual"},
+    returns_graph=True,
 )
 def boykov_kolmogorov(
     G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None
diff --git a/networkx/algorithms/flow/dinitz_alg.py b/networkx/algorithms/flow/dinitz_alg.py
index b40fd78351f..31c1a5e2a1c 100644
--- a/networkx/algorithms/flow/dinitz_alg.py
+++ b/networkx/algorithms/flow/dinitz_alg.py
@@ -15,6 +15,7 @@
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_graph_attrs={"residual"},
+    returns_graph=True,
 )
 def dinitz(G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None):
     """Find a maximum single-commodity flow using Dinitz' algorithm.
diff --git a/networkx/algorithms/flow/edmondskarp.py b/networkx/algorithms/flow/edmondskarp.py
index 6fa76d7cabc..92d79f181f2 100644
--- a/networkx/algorithms/flow/edmondskarp.py
+++ b/networkx/algorithms/flow/edmondskarp.py
@@ -12,6 +12,7 @@
     graphs="R",
     preserve_edge_attrs={"R": {"capacity": float("inf"), "flow": 0}},
     preserve_graph_attrs=True,
+    mutates_input=True,
 )
 def edmonds_karp_core(R, s, t, cutoff):
     """Implementation of the Edmonds-Karp algorithm."""
@@ -127,6 +128,7 @@ def edmonds_karp_impl(G, s, t, capacity, residual, cutoff):
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_graph_attrs={"residual"},
+    returns_graph=True,
 )
 def edmonds_karp(
     G, s, t, capacity="capacity", residual=None, value_only=False, cutoff=None
diff --git a/networkx/algorithms/flow/gomory_hu.py b/networkx/algorithms/flow/gomory_hu.py
index 802c9621d80..951abaeb517 100644
--- a/networkx/algorithms/flow/gomory_hu.py
+++ b/networkx/algorithms/flow/gomory_hu.py
@@ -13,7 +13,7 @@
 
 
 @not_implemented_for("directed")
-@nx._dispatchable(edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(edge_attrs={"capacity": float("inf")}, returns_graph=True)
 def gomory_hu_tree(G, capacity="capacity", flow_func=None):
     r"""Returns the Gomory-Hu tree of an undirected graph G.
 
diff --git a/networkx/algorithms/flow/preflowpush.py b/networkx/algorithms/flow/preflowpush.py
index 50f6c8503a7..5afa548060c 100644
--- a/networkx/algorithms/flow/preflowpush.py
+++ b/networkx/algorithms/flow/preflowpush.py
@@ -293,6 +293,7 @@ def global_relabel(from_sink):
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_graph_attrs={"residual"},
+    returns_graph=True,
 )
 def preflow_push(
     G, s, t, capacity="capacity", residual=None, global_relabel_freq=1, value_only=False
diff --git a/networkx/algorithms/flow/shortestaugmentingpath.py b/networkx/algorithms/flow/shortestaugmentingpath.py
index ba50f7acb0c..c2583d16646 100644
--- a/networkx/algorithms/flow/shortestaugmentingpath.py
+++ b/networkx/algorithms/flow/shortestaugmentingpath.py
@@ -168,6 +168,7 @@ def relabel(u):
     edge_attrs={"capacity": float("inf")},
     preserve_edge_attrs={"residual": {"capacity": float("inf")}},
     preserve_graph_attrs={"residual"},
+    returns_graph=True,
 )
 def shortest_augmenting_path(
     G,
diff --git a/networkx/algorithms/flow/utils.py b/networkx/algorithms/flow/utils.py
index 20ee78e0ae6..dcb663f3b64 100644
--- a/networkx/algorithms/flow/utils.py
+++ b/networkx/algorithms/flow/utils.py
@@ -72,7 +72,7 @@ def clear_work(self):
         self._work = 0
 
 
-@nx._dispatchable(edge_attrs={"capacity": float("inf")})
+@nx._dispatchable(edge_attrs={"capacity": float("inf")}, returns_graph=True)
 def build_residual_network(G, capacity):
     """Build a residual network and initialize a zero flow.
 
diff --git a/networkx/algorithms/hybrid.py b/networkx/algorithms/hybrid.py
index c98774e002e..4d0e5c36e80 100644
--- a/networkx/algorithms/hybrid.py
+++ b/networkx/algorithms/hybrid.py
@@ -10,7 +10,7 @@
 __all__ = ["kl_connected_subgraph", "is_kl_connected"]
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def kl_connected_subgraph(G, k, l, low_memory=False, same_as_graph=False):
     """Returns the maximum locally `(k, l)`-connected subgraph of `G`.
 
diff --git a/networkx/algorithms/isomorphism/tree_isomorphism.py b/networkx/algorithms/isomorphism/tree_isomorphism.py
index 71a5890a116..e409d515f1c 100644
--- a/networkx/algorithms/isomorphism/tree_isomorphism.py
+++ b/networkx/algorithms/isomorphism/tree_isomorphism.py
@@ -24,7 +24,7 @@
 __all__ = ["rooted_tree_isomorphism", "tree_isomorphism"]
 
 
-@nx._dispatchable(graphs={"t1": 0, "t2": 2})
+@nx._dispatchable(graphs={"t1": 0, "t2": 2}, returns_graph=True)
 def root_trees(t1, root1, t2, root2):
     """Create a single digraph dT of free trees t1 and t2
     #   with roots root1 and root2 respectively
diff --git a/networkx/algorithms/minors/contraction.py b/networkx/algorithms/minors/contraction.py
index ed29a7ac7c5..9f4d89fa802 100644
--- a/networkx/algorithms/minors/contraction.py
+++ b/networkx/algorithms/minors/contraction.py
@@ -95,7 +95,7 @@ def equivalence_classes(iterable, relation):
     return {frozenset(block) for block in blocks}
 
 
-@nx._dispatchable(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight", returns_graph=True)
 def quotient_graph(
     G,
     partition,
@@ -424,7 +424,9 @@ def edge_data(b, c):
     return H
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(
+    preserve_all_attrs=True, mutates_input={"not copy": 4}, returns_graph=True
+)
 def contracted_nodes(G, u, v, self_loops=True, copy=True):
     """Returns the graph that results from contracting `u` and `v`.
 
@@ -559,7 +561,9 @@ def contracted_nodes(G, u, v, self_loops=True, copy=True):
 identified_nodes = contracted_nodes
 
 
-@nx._dispatchable(preserve_edge_attrs=True)
+@nx._dispatchable(
+    preserve_edge_attrs=True, mutates_input={"not copy": 3}, returns_graph=True
+)
 def contracted_edge(G, edge, self_loops=True, copy=True):
     """Returns the graph that results from contracting the specified edge.
 
diff --git a/networkx/algorithms/moral.py b/networkx/algorithms/moral.py
index 8532f2b261f..e2acf80f6c3 100644
--- a/networkx/algorithms/moral.py
+++ b/networkx/algorithms/moral.py
@@ -9,7 +9,7 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def moral_graph(G):
     r"""Return the Moral Graph
 
diff --git a/networkx/algorithms/operators/all.py b/networkx/algorithms/operators/all.py
index e6f4d60b040..ba1304b6c4f 100644
--- a/networkx/algorithms/operators/all.py
+++ b/networkx/algorithms/operators/all.py
@@ -7,7 +7,7 @@
 __all__ = ["union_all", "compose_all", "disjoint_union_all", "intersection_all"]
 
 
-@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True)
+@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True, returns_graph=True)
 def union_all(graphs, rename=()):
     """Returns the union of all graphs.
 
@@ -110,7 +110,7 @@ def label(x):
     return R
 
 
-@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True)
+@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True, returns_graph=True)
 def disjoint_union_all(graphs):
     """Returns the disjoint union of all graphs.
 
@@ -164,7 +164,7 @@ def yield_relabeled(graphs):
     return R
 
 
-@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True)
+@nx._dispatchable(graphs="[graphs]", preserve_all_attrs=True, returns_graph=True)
 def compose_all(graphs):
     """Returns the composition of all graphs.
 
@@ -230,7 +230,7 @@ def compose_all(graphs):
     return R
 
 
-@nx._dispatchable(graphs="[graphs]")
+@nx._dispatchable(graphs="[graphs]", returns_graph=True)
 def intersection_all(graphs):
     """Returns a new graph that contains only the nodes and the edges that exist in
     all graphs.
diff --git a/networkx/algorithms/operators/binary.py b/networkx/algorithms/operators/binary.py
index 2b69aaf084d..0ca3a7b6bd2 100644
--- a/networkx/algorithms/operators/binary.py
+++ b/networkx/algorithms/operators/binary.py
@@ -15,7 +15,7 @@
 _G_H = {"G": 0, "H": 1}
 
 
-@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True, returns_graph=True)
 def union(G, H, rename=()):
     """Combine graphs G and H. The names of nodes must be unique.
 
@@ -71,7 +71,7 @@ def union(G, H, rename=()):
     return nx.union_all([G, H], rename)
 
 
-@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True, returns_graph=True)
 def disjoint_union(G, H):
     """Combine graphs G and H. The nodes are assumed to be unique (disjoint).
 
@@ -125,7 +125,7 @@ def disjoint_union(G, H):
     return nx.disjoint_union_all([G, H])
 
 
-@nx._dispatchable(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H, returns_graph=True)
 def intersection(G, H):
     """Returns a new graph that contains only the nodes and the edges that exist in
     both G and H.
@@ -170,7 +170,7 @@ def intersection(G, H):
     return nx.intersection_all([G, H])
 
 
-@nx._dispatchable(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H, returns_graph=True)
 def difference(G, H):
     """Returns a new graph that contains the edges that exist in G but not in H.
 
@@ -225,7 +225,7 @@ def difference(G, H):
     return R
 
 
-@nx._dispatchable(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H, returns_graph=True)
 def symmetric_difference(G, H):
     """Returns new graph with edges that exist in either G or H but not both.
 
@@ -288,7 +288,7 @@ def symmetric_difference(G, H):
     return R
 
 
-@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True, returns_graph=True)
 def compose(G, H):
     """Compose graph G with H by combining nodes and edges into a single graph.
 
@@ -369,7 +369,7 @@ def compose(G, H):
     return nx.compose_all([G, H])
 
 
-@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_all_attrs=True, returns_graph=True)
 def full_join(G, H, rename=(None, None)):
     """Returns the full join of graphs G and H.
 
diff --git a/networkx/algorithms/operators/product.py b/networkx/algorithms/operators/product.py
index 07bebdaa4b4..dc342700480 100644
--- a/networkx/algorithms/operators/product.py
+++ b/networkx/algorithms/operators/product.py
@@ -124,7 +124,7 @@ def _init_product_graph(G, H):
     return GH
 
 
-@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True, returns_graph=True)
 def tensor_product(G, H):
     r"""Returns the tensor product of G and H.
 
@@ -180,7 +180,7 @@ def tensor_product(G, H):
     return GH
 
 
-@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True, returns_graph=True)
 def cartesian_product(G, H):
     r"""Returns the Cartesian product of G and H.
 
@@ -232,7 +232,7 @@ def cartesian_product(G, H):
     return GH
 
 
-@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True, returns_graph=True)
 def lexicographic_product(G, H):
     r"""Returns the lexicographic product of G and H.
 
@@ -285,7 +285,7 @@ def lexicographic_product(G, H):
     return GH
 
 
-@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True)
+@nx._dispatchable(graphs=_G_H, preserve_node_attrs=True, returns_graph=True)
 def strong_product(G, H):
     r"""Returns the strong product of G and H.
 
@@ -343,7 +343,7 @@ def strong_product(G, H):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def power(G, k):
     """Returns the specified power of a graph.
 
@@ -432,7 +432,7 @@ def power(G, k):
 
 
 @not_implemented_for("multigraph")
-@nx._dispatchable(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H, returns_graph=True)
 def rooted_product(G, H, root):
     """Return the rooted product of graphs G and H rooted at root in H.
 
@@ -472,7 +472,7 @@ def rooted_product(G, H, root):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatchable(graphs=_G_H)
+@nx._dispatchable(graphs=_G_H, returns_graph=True)
 def corona_product(G, H):
     r"""Returns the Corona product of G and H.
 
@@ -535,7 +535,9 @@ def corona_product(G, H):
     return GH
 
 
-@nx._dispatchable(graphs=_G_H, preserve_edge_attrs=True, preserve_node_attrs=True)
+@nx._dispatchable(
+    graphs=_G_H, preserve_edge_attrs=True, preserve_node_attrs=True, returns_graph=True
+)
 def modular_product(G, H):
     r"""Returns the Modular product of G and H.
 
diff --git a/networkx/algorithms/operators/unary.py b/networkx/algorithms/operators/unary.py
index 9b1480a8012..64be249f634 100644
--- a/networkx/algorithms/operators/unary.py
+++ b/networkx/algorithms/operators/unary.py
@@ -4,7 +4,7 @@
 __all__ = ["complement", "reverse"]
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def complement(G):
     """Returns the graph complement of G.
 
@@ -40,7 +40,7 @@ def complement(G):
     return R
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def reverse(G, copy=True):
     """Returns the reverse directed graph of G.
 
diff --git a/networkx/algorithms/planarity.py b/networkx/algorithms/planarity.py
index db494481cd1..cfbb36a5c5e 100644
--- a/networkx/algorithms/planarity.py
+++ b/networkx/algorithms/planarity.py
@@ -38,7 +38,7 @@ def is_planar(G):
     return check_planarity(G, counterexample=False)[0]
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def check_planarity(G, counterexample=False):
     """Check if a graph is planar and return a counterexample or an embedding.
 
@@ -114,7 +114,7 @@ def check_planarity(G, counterexample=False):
         return True, embedding
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def check_planarity_recursive(G, counterexample=False):
     """Recursive version of :meth:`check_planarity`."""
     planarity_state = LRPlanarity(G)
@@ -130,7 +130,7 @@ def check_planarity_recursive(G, counterexample=False):
         return True, embedding
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def get_counterexample(G):
     """Obtains a Kuratowski subgraph.
 
@@ -169,7 +169,7 @@ def get_counterexample(G):
     return subgraph
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def get_counterexample_recursive(G):
     """Recursive version of :meth:`get_counterexample`."""
 
diff --git a/networkx/algorithms/regular.py b/networkx/algorithms/regular.py
index 01027cd8677..058ad365457 100644
--- a/networkx/algorithms/regular.py
+++ b/networkx/algorithms/regular.py
@@ -71,7 +71,7 @@ def is_k_regular(G, k):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatchable(preserve_edge_attrs=True)
+@nx._dispatchable(preserve_edge_attrs=True, returns_graph=True)
 def k_factor(G, k, matching_weight="weight"):
     """Compute a k-factor of G
 
diff --git a/networkx/algorithms/smallworld.py b/networkx/algorithms/smallworld.py
index 1c89e243e7d..8ddf74887f2 100644
--- a/networkx/algorithms/smallworld.py
+++ b/networkx/algorithms/smallworld.py
@@ -23,7 +23,7 @@
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(3)
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def random_reference(G, niter=1, connectivity=True, seed=None):
     """Compute a random graph by swapping edges of a given graph.
 
@@ -121,7 +121,7 @@ def random_reference(G, niter=1, connectivity=True, seed=None):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(4)
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def lattice_reference(G, niter=5, D=None, connectivity=True, seed=None):
     """Latticize the given graph by swapping edges.
 
diff --git a/networkx/algorithms/sparsifiers.py b/networkx/algorithms/sparsifiers.py
index fedc16cdd2d..870b7ba6f37 100644
--- a/networkx/algorithms/sparsifiers.py
+++ b/networkx/algorithms/sparsifiers.py
@@ -10,7 +10,7 @@
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 @py_random_state(3)
-@nx._dispatchable(edge_attrs="weight")
+@nx._dispatchable(edge_attrs="weight", returns_graph=True)
 def spanner(G, stretch, weight=None, seed=None):
     """Returns a spanner of the given graph with the given stretch.
 
diff --git a/networkx/algorithms/summarization.py b/networkx/algorithms/summarization.py
index bdabbaaf039..794a77ab34a 100644
--- a/networkx/algorithms/summarization.py
+++ b/networkx/algorithms/summarization.py
@@ -65,7 +65,7 @@
 __all__ = ["dedensify", "snap_aggregation"]
 
 
-@nx._dispatchable
+@nx._dispatchable(mutates_input={"not copy": 3}, returns_graph=True)
 def dedensify(G, threshold, prefix=None, copy=True):
     """Compresses neighborhoods around high-degree nodes
 
@@ -404,7 +404,9 @@ def _snap_split(groups, neighbor_info, group_lookup, group_id):
     return groups
 
 
-@nx._dispatchable(node_attrs="[node_attributes]", edge_attrs="[edge_attributes]")
+@nx._dispatchable(
+    node_attrs="[node_attributes]", edge_attrs="[edge_attributes]", returns_graph=True
+)
 def snap_aggregation(
     G,
     node_attributes,
diff --git a/networkx/algorithms/swap.py b/networkx/algorithms/swap.py
index 6c4b698f1ad..c190f970b6f 100644
--- a/networkx/algorithms/swap.py
+++ b/networkx/algorithms/swap.py
@@ -11,7 +11,7 @@
 
 @nx.utils.not_implemented_for("undirected")
 @py_random_state(3)
-@nx._dispatchable
+@nx._dispatchable(mutates_input=True, returns_graph=True)
 def directed_edge_swap(G, *, nswap=1, max_tries=100, seed=None):
     """Swap three edges in a directed graph while keeping the node degrees fixed.
 
@@ -133,7 +133,7 @@ def directed_edge_swap(G, *, nswap=1, max_tries=100, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable
+@nx._dispatchable(mutates_input=True, returns_graph=True)
 def double_edge_swap(G, nswap=1, max_tries=100, seed=None):
     """Swap two edges in the graph while keeping the node degrees fixed.
 
@@ -231,7 +231,7 @@ def double_edge_swap(G, nswap=1, max_tries=100, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable
+@nx._dispatchable(mutates_input=True)
 def connected_double_edge_swap(G, nswap=1, _window_threshold=3, seed=None):
     """Attempts the specified number of double-edge swaps in the graph `G`.
 
diff --git a/networkx/algorithms/threshold.py b/networkx/algorithms/threshold.py
index 374e9693ecf..bcc03d10621 100644
--- a/networkx/algorithms/threshold.py
+++ b/networkx/algorithms/threshold.py
@@ -301,7 +301,7 @@ def weights_to_creation_sequence(
 
 
 # Manipulating NetworkX.Graphs in context of threshold graphs
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def threshold_graph(creation_sequence, create_using=None):
     """
     Create a threshold graph from the creation sequence or compact
@@ -369,7 +369,7 @@ def find_alternating_4_cycle(G):
     return False
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def find_threshold_graph(G, create_using=None):
     """
     Returns a threshold subgraph that is close to largest in `G`.
diff --git a/networkx/algorithms/tournament.py b/networkx/algorithms/tournament.py
index 3cf655f40ff..43a71faa70e 100644
--- a/networkx/algorithms/tournament.py
+++ b/networkx/algorithms/tournament.py
@@ -151,7 +151,7 @@ def hamiltonian_path(G):
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_tournament(n, seed=None):
     r"""Returns a random tournament graph on `n` nodes.
 
diff --git a/networkx/algorithms/traversal/breadth_first_search.py b/networkx/algorithms/traversal/breadth_first_search.py
index d7aba232dde..b87cca124a6 100644
--- a/networkx/algorithms/traversal/breadth_first_search.py
+++ b/networkx/algorithms/traversal/breadth_first_search.py
@@ -218,7 +218,7 @@ def bfs_edges(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
         yield from generic_bfs_edges(G, source, successors, depth_limit)
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def bfs_tree(G, source, reverse=False, depth_limit=None, sort_neighbors=None):
     """Returns an oriented tree constructed from of a breadth-first-search
     starting at source.
diff --git a/networkx/algorithms/traversal/depth_first_search.py b/networkx/algorithms/traversal/depth_first_search.py
index 8a06a96c7ac..3ca0f91d964 100644
--- a/networkx/algorithms/traversal/depth_first_search.py
+++ b/networkx/algorithms/traversal/depth_first_search.py
@@ -111,7 +111,7 @@ def dfs_edges(G, source=None, depth_limit=None, *, sort_neighbors=None):
                 depth_now -= 1
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def dfs_tree(G, source=None, depth_limit=None, *, sort_neighbors=None):
     """Returns oriented tree constructed from a depth-first-search from source.
 
diff --git a/networkx/algorithms/tree/branchings.py b/networkx/algorithms/tree/branchings.py
index e6c84051d8b..34593ea4100 100644
--- a/networkx/algorithms/tree/branchings.py
+++ b/networkx/algorithms/tree/branchings.py
@@ -107,7 +107,7 @@ def branching_weight(G, attr="weight", default=1):
 
 
 @py_random_state(4)
-@nx._dispatchable(edge_attrs={"attr": "default"})
+@nx._dispatchable(edge_attrs={"attr": "default"}, returns_graph=True)
 def greedy_branching(G, attr="weight", default=1, kind="max", seed=None):
     """
     Returns a branching obtained through a greedy algorithm.
@@ -746,6 +746,7 @@ def is_root(G, u, edgekeys):
 @nx._dispatchable(
     edge_attrs={"attr": "default", "partition": 0},
     preserve_edge_attrs="preserve_attrs",
+    returns_graph=True,
 )
 def maximum_branching(
     G,
@@ -1174,6 +1175,7 @@ def is_root(G, u, edgekeys):
 @nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
+    returns_graph=True,
 )
 def minimum_branching(
     G, attr="weight", default=1, preserve_attrs=False, partition=None
@@ -1195,6 +1197,7 @@ def minimum_branching(
 @nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
+    returns_graph=True,
 )
 def minimal_branching(
     G, /, *, attr="weight", default=1, preserve_attrs=False, partition=None
@@ -1259,6 +1262,7 @@ def minimal_branching(
 @nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
+    returns_graph=True,
 )
 def maximum_spanning_arborescence(
     G, attr="weight", default=1, preserve_attrs=False, partition=None
@@ -1301,6 +1305,7 @@ def maximum_spanning_arborescence(
 @nx._dispatchable(
     edge_attrs={"attr": "default", "partition": None},
     preserve_edge_attrs="preserve_attrs",
+    returns_graph=True,
 )
 def minimum_spanning_arborescence(
     G, attr="weight", default=1, preserve_attrs=False, partition=None
diff --git a/networkx/algorithms/tree/coding.py b/networkx/algorithms/tree/coding.py
index 55344dbcbcf..8cec023c228 100644
--- a/networkx/algorithms/tree/coding.py
+++ b/networkx/algorithms/tree/coding.py
@@ -128,7 +128,7 @@ def _make_tuple(T, root, _parent):
     return _make_tuple(T, root, None)
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_nested_tuple(sequence, sensible_relabeling=False):
     """Returns the rooted tree corresponding to the given nested tuple.
 
@@ -314,7 +314,7 @@ def parents(u):
     return result
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_prufer_sequence(sequence):
     r"""Returns the tree corresponding to the given Prüfer sequence.
 
diff --git a/networkx/algorithms/tree/decomposition.py b/networkx/algorithms/tree/decomposition.py
index a649288ffe8..c8b8f2477b4 100644
--- a/networkx/algorithms/tree/decomposition.py
+++ b/networkx/algorithms/tree/decomposition.py
@@ -10,7 +10,7 @@
 
 
 @not_implemented_for("multigraph")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def junction_tree(G):
     r"""Returns a junction tree of a given graph.
 
diff --git a/networkx/algorithms/tree/mst.py b/networkx/algorithms/tree/mst.py
index 8b76bc470ab..850536edf6c 100644
--- a/networkx/algorithms/tree/mst.py
+++ b/networkx/algorithms/tree/mst.py
@@ -555,7 +555,7 @@ def maximum_spanning_edges(
     )
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def minimum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=False):
     """Returns a minimum spanning tree or forest on an undirected graph `G`.
 
@@ -615,7 +615,7 @@ def minimum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=Fa
     return T
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def partition_spanning_tree(
     G, minimum=True, weight="weight", partition="partition", ignore_nan=False
 ):
@@ -679,7 +679,7 @@ def partition_spanning_tree(
     return T
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def maximum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=False):
     """Returns a maximum spanning tree or forest on an undirected graph `G`.
 
@@ -743,7 +743,7 @@ def maximum_spanning_tree(G, weight="weight", algorithm="kruskal", ignore_nan=Fa
 
 
 @py_random_state(3)
-@nx._dispatchable(preserve_edge_attrs=True)
+@nx._dispatchable(preserve_edge_attrs=True, returns_graph=True)
 def random_spanning_tree(G, weight=None, *, multiplicative=True, seed=None):
     """
     Sample a random spanning tree using the edges weights of `G`.
diff --git a/networkx/algorithms/tree/operations.py b/networkx/algorithms/tree/operations.py
index 14b7c232bcf..f4368d6a322 100644
--- a/networkx/algorithms/tree/operations.py
+++ b/networkx/algorithms/tree/operations.py
@@ -32,7 +32,7 @@ def join(rooted_trees, label_attribute=None):
 
 
 # Argument types don't match dispatching, but allow manual selection of backend
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def join_trees(rooted_trees, *, label_attribute=None, first_label=0):
     """Returns a new rooted tree made by joining `rooted_trees`
 
diff --git a/networkx/algorithms/triads.py b/networkx/algorithms/triads.py
index 74b2f51b9db..1e67c145362 100644
--- a/networkx/algorithms/triads.py
+++ b/networkx/algorithms/triads.py
@@ -354,7 +354,7 @@ def all_triplets(G):
 
 
 @not_implemented_for("undirected")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def all_triads(G):
     """A generator of all possible triads in G.
 
@@ -547,7 +547,7 @@ def triad_type(G):
 
 @not_implemented_for("undirected")
 @py_random_state(1)
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def random_triad(G, seed=None):
     """Returns a random triad from a directed graph.
 
diff --git a/networkx/convert.py b/networkx/convert.py
index af2847aef0c..7cc8fe40126 100644
--- a/networkx/convert.py
+++ b/networkx/convert.py
@@ -202,7 +202,7 @@ def to_dict_of_lists(G, nodelist=None):
     return d
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_dict_of_lists(d, create_using=None):
     """Returns a graph from a dictionary of lists.
 
@@ -362,7 +362,7 @@ def to_dict_of_dicts(G, nodelist=None, edge_data=None):
     return dod
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_dict_of_dicts(d, create_using=None, multigraph_input=False):
     """Returns a graph from a dictionary of dictionaries.
 
@@ -467,7 +467,7 @@ def to_edgelist(G, nodelist=None):
     return G.edges(nodelist, data=True)
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_edgelist(edgelist, create_using=None):
     """Returns a graph from a list of edges.
 
diff --git a/networkx/convert_matrix.py b/networkx/convert_matrix.py
index 3e9ed1f8b46..f669a09ca5d 100644
--- a/networkx/convert_matrix.py
+++ b/networkx/convert_matrix.py
@@ -150,7 +150,7 @@ def to_pandas_adjacency(
     return pd.DataFrame(data=M, index=nodelist, columns=nodelist)
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_pandas_adjacency(df, create_using=None):
     r"""Returns a graph from Pandas DataFrame.
 
@@ -311,7 +311,7 @@ def to_pandas_edgelist(
     return pd.DataFrame(edgelistdict, dtype=dtype)
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_pandas_edgelist(
     df,
     source="source",
@@ -675,7 +675,7 @@ def _generate_weighted_edges(A):
     return _coo_gen_triples(A.tocoo())
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_scipy_sparse_array(
     A, parallel_edges=False, create_using=None, edge_attribute="weight"
 ):
@@ -1017,7 +1017,7 @@ def to_numpy_array(
     return A
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_numpy_array(A, parallel_edges=False, create_using=None, edge_attr="weight"):
     """Returns a graph from a 2D NumPy array.
 
diff --git a/networkx/drawing/nx_agraph.py b/networkx/drawing/nx_agraph.py
index 1682c62dcf1..f91031fcae6 100644
--- a/networkx/drawing/nx_agraph.py
+++ b/networkx/drawing/nx_agraph.py
@@ -33,7 +33,7 @@
 ]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_agraph(A, create_using=None):
     """Returns a NetworkX Graph or DiGraph from a PyGraphviz graph.
 
@@ -203,7 +203,7 @@ def write_dot(G, path):
     return
 
 
-@nx._dispatchable(name="agraph_read_dot", graphs=None)
+@nx._dispatchable(name="agraph_read_dot", graphs=None, returns_graph=True)
 def read_dot(path):
     """Returns a NetworkX graph from a dot file on path.
 
diff --git a/networkx/drawing/nx_pydot.py b/networkx/drawing/nx_pydot.py
index 77ae7278863..92c5f333e1c 100644
--- a/networkx/drawing/nx_pydot.py
+++ b/networkx/drawing/nx_pydot.py
@@ -46,7 +46,7 @@ def write_dot(G, path):
 
 
 @open_file(0, mode="r")
-@nx._dispatchable(name="pydot_read_dot", graphs=None)
+@nx._dispatchable(name="pydot_read_dot", graphs=None, returns_graph=True)
 def read_dot(path):
     """Returns a NetworkX :class:`MultiGraph` or :class:`MultiDiGraph` from the
     dot file with the passed path.
@@ -80,7 +80,7 @@ def read_dot(path):
     return from_pydot(P_list[0])
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_pydot(P):
     """Returns a NetworkX graph from a Pydot graph.
 
diff --git a/networkx/generators/atlas.py b/networkx/generators/atlas.py
index 0a34bc466b8..262443628c8 100644
--- a/networkx/generators/atlas.py
+++ b/networkx/generators/atlas.py
@@ -88,7 +88,7 @@ def _generate_graphs():
             yield G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def graph_atlas(i):
     """Returns graph number `i` from the Graph Atlas.
 
@@ -127,7 +127,7 @@ def graph_atlas(i):
     return next(islice(_generate_graphs(), i, None))
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def graph_atlas_g():
     """Returns the list of all graphs with up to seven nodes named in the
     Graph Atlas.
diff --git a/networkx/generators/classic.py b/networkx/generators/classic.py
index 51ff86c1da3..54088be7519 100644
--- a/networkx/generators/classic.py
+++ b/networkx/generators/classic.py
@@ -66,7 +66,7 @@ def _tree_edges(n, r):
                 break
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def full_rary_tree(r, n, create_using=None):
     """Creates a full r-ary tree of `n` nodes.
 
@@ -104,7 +104,7 @@ def full_rary_tree(r, n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def kneser_graph(n, k):
     """Returns the Kneser Graph with parameters `n` and `k`.
 
@@ -151,7 +151,7 @@ def kneser_graph(n, k):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def balanced_tree(r, h, create_using=None):
     """Returns the perfectly balanced `r`-ary tree of height `h`.
 
@@ -201,7 +201,7 @@ def balanced_tree(r, h, create_using=None):
     return full_rary_tree(r, n, create_using=create_using)
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def barbell_graph(m1, m2, create_using=None):
     """Returns the Barbell Graph: two complete graphs connected by a path.
 
@@ -274,7 +274,7 @@ def barbell_graph(m1, m2, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def binomial_tree(n, create_using=None):
     """Returns the Binomial Tree of order n.
 
@@ -312,7 +312,7 @@ def binomial_tree(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number(0)
 def complete_graph(n, create_using=None):
     """Return the complete graph `K_n` with n nodes.
@@ -360,7 +360,7 @@ def complete_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def circular_ladder_graph(n, create_using=None):
     """Returns the circular ladder graph $CL_n$ of length n.
 
@@ -380,7 +380,7 @@ def circular_ladder_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def circulant_graph(n, offsets, create_using=None):
     r"""Returns the circulant graph $Ci_n(x_1, x_2, ..., x_m)$ with $n$ nodes.
 
@@ -455,7 +455,7 @@ def circulant_graph(n, offsets, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number(0)
 def cycle_graph(n, create_using=None):
     """Returns the cycle graph $C_n$ of cyclically connected nodes.
@@ -487,7 +487,7 @@ def cycle_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def dorogovtsev_goltsev_mendes_graph(n, create_using=None):
     """Returns the hierarchically constructed Dorogovtsev-Goltsev-Mendes graph.
 
@@ -549,7 +549,7 @@ def dorogovtsev_goltsev_mendes_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number(0)
 def empty_graph(n=0, create_using=None, default=Graph):
     """Returns the empty graph with n nodes and zero edges.
@@ -648,7 +648,7 @@ def empty_graph(n=0, create_using=None, default=Graph):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def ladder_graph(n, create_using=None):
     """Returns the Ladder graph of length n.
 
@@ -671,7 +671,7 @@ def ladder_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number([0, 1])
 def lollipop_graph(m, n, create_using=None):
     """Returns the Lollipop Graph; ``K_m`` connected to ``P_n``.
@@ -738,7 +738,7 @@ def lollipop_graph(m, n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def null_graph(create_using=None):
     """Returns the Null graph with no nodes or edges.
 
@@ -749,7 +749,7 @@ def null_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number(0)
 def path_graph(n, create_using=None):
     """Returns the Path graph `P_n` of linearly connected nodes.
@@ -775,7 +775,7 @@ def path_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number(0)
 def star_graph(n, create_using=None):
     """Return the star graph
@@ -814,7 +814,7 @@ def star_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number([0, 1])
 def tadpole_graph(m, n, create_using=None):
     """Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
@@ -876,7 +876,7 @@ def tadpole_graph(m, n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def trivial_graph(create_using=None):
     """Return the Trivial graph with one node (with label 0) and no edges.
 
@@ -889,7 +889,7 @@ def trivial_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def turan_graph(n, r):
     r"""Return the Turan Graph
 
@@ -927,7 +927,7 @@ def turan_graph(n, r):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number(0)
 def wheel_graph(n, create_using=None):
     """Return the wheel graph
@@ -963,7 +963,7 @@ def wheel_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def complete_multipartite_graph(*subset_sizes):
     """Returns the complete multipartite graph with the specified subset sizes.
 
diff --git a/networkx/generators/cographs.py b/networkx/generators/cographs.py
index 50f38ed76bf..388a42ac529 100644
--- a/networkx/generators/cographs.py
+++ b/networkx/generators/cographs.py
@@ -18,7 +18,7 @@
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_cograph(n, seed=None):
     r"""Returns a random cograph with $2 ^ n$ nodes.
 
diff --git a/networkx/generators/community.py b/networkx/generators/community.py
index 5a3d31c6833..5076d728840 100644
--- a/networkx/generators/community.py
+++ b/networkx/generators/community.py
@@ -19,7 +19,7 @@
 ]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def caveman_graph(l, k):
     """Returns a caveman graph of `l` cliques of size `k`.
 
@@ -66,7 +66,7 @@ def caveman_graph(l, k):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def connected_caveman_graph(l, k):
     """Returns a connected caveman graph of `l` cliques of size `k`.
 
@@ -121,7 +121,7 @@ def connected_caveman_graph(l, k):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def relaxed_caveman_graph(l, k, p, seed=None):
     """Returns a relaxed caveman graph.
 
@@ -173,7 +173,7 @@ def relaxed_caveman_graph(l, k, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_partition_graph(sizes, p_in, p_out, seed=None, directed=False):
     """Returns the random partition graph with a partition of sizes.
 
@@ -252,7 +252,7 @@ def random_partition_graph(sizes, p_in, p_out, seed=None, directed=False):
 
 
 @py_random_state(4)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def planted_partition_graph(l, k, p_in, p_out, seed=None, directed=False):
     """Returns the planted l-partition graph.
 
@@ -308,7 +308,7 @@ def planted_partition_graph(l, k, p_in, p_out, seed=None, directed=False):
 
 
 @py_random_state(6)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def gaussian_random_partition_graph(n, s, v, p_in, p_out, directed=False, seed=None):
     """Generate a Gaussian random partition graph.
 
@@ -384,7 +384,7 @@ def gaussian_random_partition_graph(n, s, v, p_in, p_out, directed=False, seed=N
     return random_partition_graph(sizes, p_in, p_out, seed=seed, directed=directed)
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def ring_of_cliques(num_cliques, clique_size):
     """Defines a "ring of cliques" graph.
 
@@ -440,7 +440,7 @@ def ring_of_cliques(num_cliques, clique_size):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def windmill_graph(n, k):
     """Generate a windmill graph.
     A windmill graph is a graph of `n` cliques each of size `k` that are all
@@ -494,7 +494,7 @@ def windmill_graph(n, k):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def stochastic_block_model(
     sizes, p, nodelist=None, seed=None, directed=False, selfloops=False, sparse=True
 ):
@@ -806,7 +806,7 @@ def _generate_communities(degree_seq, community_sizes, mu, max_iters, seed):
 
 
 @py_random_state(11)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def LFR_benchmark_graph(
     n,
     tau1,
diff --git a/networkx/generators/degree_seq.py b/networkx/generators/degree_seq.py
index 0e9414dd881..6bc85e2be61 100644
--- a/networkx/generators/degree_seq.py
+++ b/networkx/generators/degree_seq.py
@@ -124,7 +124,7 @@ def _configuration_model(
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def configuration_model(deg_sequence, create_using=None, seed=None):
     """Returns a random graph with the given degree sequence.
 
@@ -227,7 +227,7 @@ def configuration_model(deg_sequence, create_using=None, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def directed_configuration_model(
     in_degree_sequence, out_degree_sequence, create_using=None, seed=None
 ):
@@ -330,7 +330,7 @@ def directed_configuration_model(
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def expected_degree_graph(w, seed=None, selfloops=True):
     r"""Returns a random graph with given expected degrees.
 
@@ -439,7 +439,7 @@ def expected_degree_graph(w, seed=None, selfloops=True):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def havel_hakimi_graph(deg_sequence, create_using=None):
     """Returns a simple graph with given degree sequence constructed
     using the Havel-Hakimi algorithm.
@@ -532,7 +532,7 @@ def havel_hakimi_graph(deg_sequence, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def directed_havel_hakimi_graph(in_deg_sequence, out_deg_sequence, create_using=None):
     """Returns a directed graph with the given degree sequences.
 
@@ -644,7 +644,7 @@ def directed_havel_hakimi_graph(in_deg_sequence, out_deg_sequence, create_using=
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def degree_sequence_tree(deg_sequence, create_using=None):
     """Make a tree for the given degree sequence.
 
@@ -691,7 +691,7 @@ def degree_sequence_tree(deg_sequence, create_using=None):
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_degree_sequence_graph(sequence, seed=None, tries=10):
     r"""Returns a simple random graph with the given degree sequence.
 
diff --git a/networkx/generators/directed.py b/networkx/generators/directed.py
index 38ddc80f899..4548726b9fe 100644
--- a/networkx/generators/directed.py
+++ b/networkx/generators/directed.py
@@ -21,7 +21,7 @@
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def gn_graph(n, kernel=None, create_using=None, seed=None):
     """Returns the growing network (GN) digraph with `n` nodes.
 
@@ -89,7 +89,7 @@ def kernel(x):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def gnr_graph(n, p, create_using=None, seed=None):
     """Returns the growing network with redirection (GNR) digraph with `n`
     nodes and redirection probability `p`.
@@ -143,7 +143,7 @@ def gnr_graph(n, p, create_using=None, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def gnc_graph(n, create_using=None, seed=None):
     """Returns the growing network with copying (GNC) digraph with `n` nodes.
 
@@ -183,7 +183,7 @@ def gnc_graph(n, create_using=None, seed=None):
 
 
 @py_random_state(6)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def scale_free_graph(
     n,
     alpha=0.41,
@@ -334,7 +334,7 @@ def _choose_node(candidates, node_list, delta):
 
 
 @py_random_state(4)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_uniform_k_out_graph(n, k, self_loops=True, with_replacement=True, seed=None):
     """Returns a random `k`-out graph with uniform attachment.
 
@@ -415,7 +415,7 @@ def sample(v, nodes):
 
 
 @py_random_state(4)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_k_out_graph(n, k, alpha, self_loops=True, seed=None):
     """Returns a random `k`-out graph with preferential attachment.
 
diff --git a/networkx/generators/duplication.py b/networkx/generators/duplication.py
index 6a2e5d57e07..ad8262382ce 100644
--- a/networkx/generators/duplication.py
+++ b/networkx/generators/duplication.py
@@ -13,7 +13,7 @@
 
 
 @py_random_state(4)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def partial_duplication_graph(N, n, p, q, seed=None):
     """Returns a random graph using the partial duplication model.
 
@@ -88,7 +88,7 @@ def partial_duplication_graph(N, n, p, q, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def duplication_divergence_graph(n, p, seed=None):
     """Returns an undirected graph using the duplication-divergence model.
 
diff --git a/networkx/generators/ego.py b/networkx/generators/ego.py
index 9803783ae1e..d959a1bd1d0 100644
--- a/networkx/generators/ego.py
+++ b/networkx/generators/ego.py
@@ -6,7 +6,7 @@
 import networkx as nx
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def ego_graph(G, n, radius=1, center=True, undirected=False, distance=None):
     """Returns induced subgraph of neighbors centered at node n within
     a given radius.
diff --git a/networkx/generators/expanders.py b/networkx/generators/expanders.py
index cc03500a470..85716e0e7a0 100644
--- a/networkx/generators/expanders.py
+++ b/networkx/generators/expanders.py
@@ -47,7 +47,7 @@
 #     (x, (y + (2*x + 1)) % n),
 #     (x, (y + (2*x + 2)) % n),
 #
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def margulis_gabber_galil_graph(n, create_using=None):
     r"""Returns the Margulis-Gabber-Galil undirected MultiGraph on `n^2` nodes.
 
@@ -90,7 +90,7 @@ def margulis_gabber_galil_graph(n, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def chordal_cycle_graph(p, create_using=None):
     """Returns the chordal cycle graph on `p` nodes.
 
@@ -154,7 +154,7 @@ def chordal_cycle_graph(p, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def paley_graph(p, create_using=None):
     r"""Returns the Paley $\frac{(p-1)}{2}$ -regular graph on $p$ nodes.
 
@@ -214,7 +214,7 @@ def paley_graph(p, create_using=None):
 
 
 @nx.utils.decorators.np_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def maybe_regular_expander(n, d, *, create_using=None, max_tries=100, seed=None):
     r"""Utility for creating a random regular expander.
 
@@ -399,7 +399,7 @@ def is_regular_expander(G, *, epsilon=0):
 
 
 @nx.utils.decorators.np_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_regular_expander_graph(
     n, d, *, epsilon=0, create_using=None, max_tries=100, seed=None
 ):
diff --git a/networkx/generators/geometric.py b/networkx/generators/geometric.py
index 468b2d36c8b..bb7fbd76d99 100644
--- a/networkx/generators/geometric.py
+++ b/networkx/generators/geometric.py
@@ -113,7 +113,7 @@ def _geometric_edges(G, radius, p, pos_name):
 
 
 @py_random_state(5)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_geometric_graph(
     n, radius, dim=2, pos=None, p=2, seed=None, *, pos_name="pos"
 ):
@@ -207,7 +207,7 @@ def random_geometric_graph(
 
 
 @py_random_state(6)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def soft_random_geometric_graph(
     n, radius, dim=2, pos=None, p=2, p_dist=None, seed=None, *, pos_name="pos"
 ):
@@ -337,7 +337,7 @@ def should_join(edge):
 
 
 @py_random_state(7)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def geographical_threshold_graph(
     n,
     theta,
@@ -504,7 +504,7 @@ def should_join(pair):
 
 
 @py_random_state(6)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def waxman_graph(
     n,
     beta=0.4,
@@ -637,7 +637,7 @@ def should_join(pair):
 
 
 @py_random_state(5)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def navigable_small_world_graph(n, p=1, q=1, r=2, dim=2, seed=None):
     r"""Returns a navigable small-world graph.
 
@@ -710,7 +710,7 @@ def navigable_small_world_graph(n, p=1, q=1, r=2, dim=2, seed=None):
 
 
 @py_random_state(7)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def thresholded_random_geometric_graph(
     n,
     radius,
@@ -850,7 +850,7 @@ def thresholded_random_geometric_graph(
 
 
 @py_random_state(5)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def geometric_soft_configuration_graph(
     *, beta, n=None, gamma=None, mean_degree=None, kappas=None, seed=None
 ):
diff --git a/networkx/generators/harary_graph.py b/networkx/generators/harary_graph.py
index 250f98985d6..591587d3aca 100644
--- a/networkx/generators/harary_graph.py
+++ b/networkx/generators/harary_graph.py
@@ -21,7 +21,7 @@
 __all__ = ["hnm_harary_graph", "hkn_harary_graph"]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def hnm_harary_graph(n, m, create_using=None):
     """Returns the Harary graph with given numbers of nodes and edges.
 
@@ -113,7 +113,7 @@ def hnm_harary_graph(n, m, create_using=None):
     return H
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def hkn_harary_graph(k, n, create_using=None):
     """Returns the Harary graph with given node connectivity and node number.
 
diff --git a/networkx/generators/internet_as_graphs.py b/networkx/generators/internet_as_graphs.py
index ad45b23d93e..449d54376af 100644
--- a/networkx/generators/internet_as_graphs.py
+++ b/networkx/generators/internet_as_graphs.py
@@ -397,7 +397,7 @@ def generate(self):
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_internet_as_graph(n, seed=None):
     """Generates a random undirected graph resembling the Internet AS network
 
diff --git a/networkx/generators/intersection.py b/networkx/generators/intersection.py
index be88448f066..2ed3a5fa310 100644
--- a/networkx/generators/intersection.py
+++ b/networkx/generators/intersection.py
@@ -12,7 +12,7 @@
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def uniform_random_intersection_graph(n, m, p, seed=None):
     """Returns a uniform random intersection graph.
 
@@ -48,7 +48,7 @@ def uniform_random_intersection_graph(n, m, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def k_random_intersection_graph(n, m, k, seed=None):
     """Returns a intersection graph with randomly chosen attribute sets for
     each node that are of equal size (k).
@@ -84,7 +84,7 @@ def k_random_intersection_graph(n, m, k, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def general_random_intersection_graph(n, m, p, seed=None):
     """Returns a random intersection graph with independent probabilities
     for connections between node and attribute sets.
diff --git a/networkx/generators/interval_graph.py b/networkx/generators/interval_graph.py
index 6373a24b34c..2a3d760901c 100644
--- a/networkx/generators/interval_graph.py
+++ b/networkx/generators/interval_graph.py
@@ -8,7 +8,7 @@
 __all__ = ["interval_graph"]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def interval_graph(intervals):
     """Generates an interval graph for a list of intervals given.
 
diff --git a/networkx/generators/joint_degree_seq.py b/networkx/generators/joint_degree_seq.py
index 7ad03288c86..c426df944ad 100644
--- a/networkx/generators/joint_degree_seq.py
+++ b/networkx/generators/joint_degree_seq.py
@@ -142,7 +142,7 @@ def _neighbor_switch(G, w, unsat, h_node_residual, avoid_node_id=None):
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def joint_degree_graph(joint_degrees, seed=None):
     """Generates a random simple graph with the given joint degree dictionary.
 
@@ -469,7 +469,7 @@ def _directed_neighbor_switch_rev(
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def directed_joint_degree_graph(in_degrees, out_degrees, nkk, seed=None):
     """Generates a random simple directed graph with the joint degree.
 
diff --git a/networkx/generators/lattice.py b/networkx/generators/lattice.py
index c046b8e9b11..95e520d2ce1 100644
--- a/networkx/generators/lattice.py
+++ b/networkx/generators/lattice.py
@@ -32,7 +32,7 @@
 ]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 @nodes_or_number([0, 1])
 def grid_2d_graph(m, n, periodic=False, create_using=None):
     """Returns the two-dimensional grid graph.
@@ -86,7 +86,7 @@ def grid_2d_graph(m, n, periodic=False, create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def grid_graph(dim, periodic=False):
     """Returns the *n*-dimensional grid graph.
 
@@ -143,7 +143,7 @@ def grid_graph(dim, periodic=False):
     return H
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def hypercube_graph(n):
     """Returns the *n*-dimensional hypercube graph.
 
@@ -170,7 +170,7 @@ def hypercube_graph(n):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def triangular_lattice_graph(
     m, n, periodic=False, with_positions=True, create_using=None
 ):
@@ -271,7 +271,7 @@ def triangular_lattice_graph(
     return H
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def hexagonal_lattice_graph(
     m, n, periodic=False, with_positions=True, create_using=None
 ):
diff --git a/networkx/generators/line.py b/networkx/generators/line.py
index b5974a038eb..57f4d16927d 100644
--- a/networkx/generators/line.py
+++ b/networkx/generators/line.py
@@ -10,7 +10,7 @@
 __all__ = ["line_graph", "inverse_line_graph"]
 
 
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def line_graph(G, create_using=None):
     r"""Returns the line graph of the graph or digraph `G`.
 
@@ -215,7 +215,7 @@ def _lg_undirected(G, selfloops=False, create_using=None):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def inverse_line_graph(G):
     """Returns the inverse line graph of graph G.
 
diff --git a/networkx/generators/mycielski.py b/networkx/generators/mycielski.py
index 492be58fd8e..804b9036928 100644
--- a/networkx/generators/mycielski.py
+++ b/networkx/generators/mycielski.py
@@ -11,7 +11,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def mycielskian(G, iterations=1):
     r"""Returns the Mycielskian of a simple, undirected graph G
 
@@ -68,7 +68,7 @@ def mycielskian(G, iterations=1):
     return M
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def mycielski_graph(n):
     """Generator for the n_th Mycielski Graph.
 
diff --git a/networkx/generators/nonisomorphic_trees.py b/networkx/generators/nonisomorphic_trees.py
index fbfcbd22e92..9d403cb848e 100644
--- a/networkx/generators/nonisomorphic_trees.py
+++ b/networkx/generators/nonisomorphic_trees.py
@@ -12,7 +12,7 @@
 import networkx as nx
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def nonisomorphic_trees(order, create="graph"):
     """Generates lists of nonisomorphic trees
 
diff --git a/networkx/generators/random_clustered.py b/networkx/generators/random_clustered.py
index abd7a8c9c6e..edf4b94b3b9 100644
--- a/networkx/generators/random_clustered.py
+++ b/networkx/generators/random_clustered.py
@@ -7,7 +7,7 @@
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_clustered_graph(joint_degree_sequence, create_using=None, seed=None):
     r"""Generate a random graph with the given joint independent edge degree and
     triangle degree sequence.
diff --git a/networkx/generators/random_graphs.py b/networkx/generators/random_graphs.py
index dc65a962123..b6f5ebf629d 100644
--- a/networkx/generators/random_graphs.py
+++ b/networkx/generators/random_graphs.py
@@ -37,7 +37,7 @@
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def fast_gnp_random_graph(n, p, seed=None, directed=False):
     """Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph or
     a binomial graph.
@@ -109,7 +109,7 @@ def fast_gnp_random_graph(n, p, seed=None, directed=False):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def gnp_random_graph(n, p, seed=None, directed=False):
     """Returns a $G_{n,p}$ random graph, also known as an Erdős-Rényi graph
     or a binomial graph.
@@ -174,7 +174,7 @@ def gnp_random_graph(n, p, seed=None, directed=False):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def dense_gnm_random_graph(n, m, seed=None):
     """Returns a $G_{n,m}$ random graph.
 
@@ -236,7 +236,7 @@ def dense_gnm_random_graph(n, m, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def gnm_random_graph(n, m, seed=None, directed=False):
     """Returns a $G_{n,m}$ random graph.
 
@@ -292,7 +292,7 @@ def gnm_random_graph(n, m, seed=None, directed=False):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def newman_watts_strogatz_graph(n, k, p, seed=None):
     """Returns a Newman–Watts–Strogatz small-world graph.
 
@@ -363,7 +363,7 @@ def newman_watts_strogatz_graph(n, k, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def watts_strogatz_graph(n, k, p, seed=None):
     """Returns a Watts–Strogatz small-world graph.
 
@@ -438,7 +438,7 @@ def watts_strogatz_graph(n, k, p, seed=None):
 
 
 @py_random_state(4)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def connected_watts_strogatz_graph(n, k, p, tries=100, seed=None):
     """Returns a connected Watts–Strogatz small-world graph.
 
@@ -491,7 +491,7 @@ def connected_watts_strogatz_graph(n, k, p, tries=100, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_regular_graph(d, n, seed=None):
     r"""Returns a random $d$-regular graph on $n$ nodes.
 
@@ -622,7 +622,7 @@ def _random_subset(seq, m, rng):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def barabasi_albert_graph(n, m, seed=None, initial_graph=None):
     """Returns a random graph using Barabási–Albert preferential attachment
 
@@ -695,7 +695,7 @@ def barabasi_albert_graph(n, m, seed=None, initial_graph=None):
 
 
 @py_random_state(4)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def dual_barabasi_albert_graph(n, m1, m2, p, seed=None, initial_graph=None):
     """Returns a random graph using dual Barabási–Albert preferential attachment
 
@@ -795,7 +795,7 @@ def dual_barabasi_albert_graph(n, m1, m2, p, seed=None, initial_graph=None):
 
 
 @py_random_state(4)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def extended_barabasi_albert_graph(n, m, p, q, seed=None):
     """Returns an extended Barabási–Albert model graph.
 
@@ -956,7 +956,7 @@ def extended_barabasi_albert_graph(n, m, p, q, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def powerlaw_cluster_graph(n, m, p, seed=None):
     """Holme and Kim algorithm for growing graphs with powerlaw
     degree distribution and approximate average clustering.
@@ -1046,7 +1046,7 @@ def powerlaw_cluster_graph(n, m, p, seed=None):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_lobster(n, p1, p2, seed=None):
     """Returns a random lobster graph.
 
@@ -1097,7 +1097,7 @@ def random_lobster(n, p1, p2, seed=None):
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_shell_graph(constructor, seed=None):
     """Returns a random shell graph for the constructor given.
 
@@ -1155,7 +1155,7 @@ def random_shell_graph(constructor, seed=None):
 
 
 @py_random_state(2)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_powerlaw_tree(n, gamma=3, seed=None, tries=100):
     """Returns a tree with a power law degree distribution.
 
@@ -1249,7 +1249,7 @@ def random_powerlaw_tree_sequence(n, gamma=3, seed=None, tries=100):
 
 
 @py_random_state(3)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_kernel_graph(n, kernel_integral, kernel_root=None, seed=None):
     r"""Returns an random graph based on the specified kernel.
 
diff --git a/networkx/generators/small.py b/networkx/generators/small.py
index 0efa62bc521..ea33e741924 100644
--- a/networkx/generators/small.py
+++ b/networkx/generators/small.py
@@ -59,7 +59,7 @@ def wrapper(*args, **kwargs):
     return wrapper
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def LCF_graph(n, shift_list, repeats, create_using=None):
     """
     Return the cubic graph specified in LCF notation.
@@ -126,7 +126,7 @@ def LCF_graph(n, shift_list, repeats, create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def bull_graph(create_using=None):
     """
     Returns the Bull Graph
@@ -160,7 +160,7 @@ def bull_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def chvatal_graph(create_using=None):
     """
     Returns the Chvátal Graph
@@ -205,7 +205,7 @@ def chvatal_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def cubical_graph(create_using=None):
     """
     Returns the 3-regular Platonic Cubical Graph
@@ -248,7 +248,7 @@ def cubical_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def desargues_graph(create_using=None):
     """
     Returns the Desargues Graph
@@ -279,7 +279,7 @@ def desargues_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def diamond_graph(create_using=None):
     """
     Returns the Diamond graph
@@ -308,7 +308,7 @@ def diamond_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def dodecahedral_graph(create_using=None):
     """
     Returns the Platonic Dodecahedral graph.
@@ -339,7 +339,7 @@ def dodecahedral_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def frucht_graph(create_using=None):
     """
     Returns the Frucht Graph.
@@ -386,7 +386,7 @@ def frucht_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def heawood_graph(create_using=None):
     """
     Returns the Heawood Graph, a (3,6) cage.
@@ -420,7 +420,7 @@ def heawood_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def hoffman_singleton_graph():
     """
     Returns the Hoffman-Singleton Graph.
@@ -464,7 +464,7 @@ def hoffman_singleton_graph():
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def house_graph(create_using=None):
     """
     Returns the House graph (square with triangle on top)
@@ -495,7 +495,7 @@ def house_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def house_x_graph(create_using=None):
     """
     Returns the House graph with a cross inside the house square.
@@ -525,7 +525,7 @@ def house_x_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def icosahedral_graph(create_using=None):
     """
     Returns the Platonic Icosahedral graph.
@@ -568,7 +568,7 @@ def icosahedral_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def krackhardt_kite_graph(create_using=None):
     """
     Returns the Krackhardt Kite Social Network.
@@ -618,7 +618,7 @@ def krackhardt_kite_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def moebius_kantor_graph(create_using=None):
     """
     Returns the Moebius-Kantor graph.
@@ -648,7 +648,7 @@ def moebius_kantor_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def octahedral_graph(create_using=None):
     """
     Returns the Platonic Octahedral graph.
@@ -683,7 +683,7 @@ def octahedral_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def pappus_graph():
     """
     Returns the Pappus graph.
@@ -707,7 +707,7 @@ def pappus_graph():
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def petersen_graph(create_using=None):
     """
     Returns the Petersen graph.
@@ -751,7 +751,7 @@ def petersen_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def sedgewick_maze_graph(create_using=None):
     """
     Return a small maze with a cycle.
@@ -784,7 +784,7 @@ def sedgewick_maze_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def tetrahedral_graph(create_using=None):
     """
     Returns the 3-regular Platonic Tetrahedral graph.
@@ -814,7 +814,7 @@ def tetrahedral_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def truncated_cube_graph(create_using=None):
     """
     Returns the skeleton of the truncated cube.
@@ -872,7 +872,7 @@ def truncated_cube_graph(create_using=None):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def truncated_tetrahedron_graph(create_using=None):
     """
     Returns the skeleton of the truncated Platonic tetrahedron.
@@ -903,7 +903,7 @@ def truncated_tetrahedron_graph(create_using=None):
 
 
 @_raise_on_directed
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def tutte_graph(create_using=None):
     """
     Returns the Tutte graph.
diff --git a/networkx/generators/social.py b/networkx/generators/social.py
index 5d950649c3e..6f150e2fc68 100644
--- a/networkx/generators/social.py
+++ b/networkx/generators/social.py
@@ -11,7 +11,7 @@
 ]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def karate_club_graph():
     """Returns Zachary's Karate Club graph.
 
@@ -93,7 +93,7 @@ def karate_club_graph():
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def davis_southern_women_graph():
     """Returns Davis Southern women social network.
 
@@ -244,7 +244,7 @@ def davis_southern_women_graph():
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def florentine_families_graph():
     """Returns Florentine families graph.
 
@@ -278,7 +278,7 @@ def florentine_families_graph():
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def les_miserables_graph():
     """Returns coappearance network of characters in the novel Les Miserables.
 
diff --git a/networkx/generators/spectral_graph_forge.py b/networkx/generators/spectral_graph_forge.py
index cdd1250fa18..3f4ee3ed951 100644
--- a/networkx/generators/spectral_graph_forge.py
+++ b/networkx/generators/spectral_graph_forge.py
@@ -8,7 +8,7 @@
 
 
 @np_random_state(3)
-@nx._dispatchable
+@nx._dispatchable(returns_graph=True)
 def spectral_graph_forge(G, alpha, transformation="identity", seed=None):
     """Returns a random simple graph with spectrum resembling that of `G`
 
diff --git a/networkx/generators/stochastic.py b/networkx/generators/stochastic.py
index 75d9c0b25b3..e3ce97e50d0 100644
--- a/networkx/generators/stochastic.py
+++ b/networkx/generators/stochastic.py
@@ -11,7 +11,9 @@
 
 
 @not_implemented_for("undirected")
-@nx._dispatchable(edge_attrs="weight")
+@nx._dispatchable(
+    edge_attrs="weight", mutates_input={"not copy": 1}, returns_graph=True
+)
 def stochastic_graph(G, copy=True, weight="weight"):
     """Returns a right-stochastic representation of directed graph `G`.
 
diff --git a/networkx/generators/sudoku.py b/networkx/generators/sudoku.py
index c8ac57c48c0..f288ed24d1f 100644
--- a/networkx/generators/sudoku.py
+++ b/networkx/generators/sudoku.py
@@ -47,7 +47,7 @@
 __all__ = ["sudoku_graph"]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def sudoku_graph(n=3):
     """Returns the n-Sudoku graph. The default value of n is 3.
 
diff --git a/networkx/generators/time_series.py b/networkx/generators/time_series.py
index ac060627bac..6cf54b01669 100644
--- a/networkx/generators/time_series.py
+++ b/networkx/generators/time_series.py
@@ -8,7 +8,7 @@
 __all__ = ["visibility_graph"]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def visibility_graph(series):
     """
     Return a Visibility Graph of an input Time Series.
diff --git a/networkx/generators/trees.py b/networkx/generators/trees.py
index 60c2fc640e3..c1b0d793526 100644
--- a/networkx/generators/trees.py
+++ b/networkx/generators/trees.py
@@ -48,7 +48,7 @@
 ]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def prefix_tree(paths):
     """Creates a directed prefix tree from a list of paths.
 
@@ -181,7 +181,7 @@ def get_children(parent, paths):
     return tree
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def prefix_tree_recursive(paths):
     """Recursively creates a directed prefix tree from a list of paths.
 
@@ -324,7 +324,7 @@ def _helper(paths, root, tree):
 
 
 @py_random_state(1)
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_tree(n, seed=None, create_using=None):
     """Returns a uniformly random tree on `n` nodes.
 
@@ -426,7 +426,7 @@ def random_tree(n, seed=None, create_using=None):
 
 
 @py_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_labeled_tree(n, *, seed=None):
     """Returns a labeled tree on `n` nodes chosen uniformly at random.
 
@@ -462,7 +462,7 @@ def random_labeled_tree(n, *, seed=None):
 
 
 @py_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_labeled_rooted_tree(n, *, seed=None):
     """Returns a labeled rooted tree with `n` nodes.
 
@@ -499,7 +499,7 @@ def random_labeled_rooted_tree(n, *, seed=None):
 
 
 @py_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_labeled_rooted_forest(n, *, seed=None):
     """Returns a labeled rooted forest with `n` nodes.
 
@@ -737,7 +737,7 @@ def _random_unlabeled_rooted_tree(n, cache_trees, seed):
 
 
 @py_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_unlabeled_rooted_tree(n, *, number_of_trees=None, seed=None):
     """Returns a number of unlabeled rooted trees uniformly at random
 
@@ -922,7 +922,7 @@ def _random_unlabeled_rooted_forest(n, q, cache_trees, cache_forests, seed):
 
 
 @py_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_unlabeled_rooted_forest(n, *, q=None, number_of_forests=None, seed=None):
     """Returns a forest or list of forests selected at random.
 
@@ -1099,7 +1099,7 @@ def _random_unlabeled_tree(n, cache_trees, cache_forests, seed):
 
 
 @py_random_state("seed")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def random_unlabeled_tree(n, *, number_of_trees=None, seed=None):
     """Returns a tree or list of trees chosen randomly.
 
diff --git a/networkx/generators/triads.py b/networkx/generators/triads.py
index f9713b5df33..5d380588bd3 100644
--- a/networkx/generators/triads.py
+++ b/networkx/generators/triads.py
@@ -33,7 +33,7 @@
 }
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def triad_graph(triad_name):
     """Returns the triad graph with the given name.
 
diff --git a/networkx/readwrite/adjlist.py b/networkx/readwrite/adjlist.py
index a14ad430086..56a1b4d2bf2 100644
--- a/networkx/readwrite/adjlist.py
+++ b/networkx/readwrite/adjlist.py
@@ -150,7 +150,7 @@ def write_adjlist(G, path, comments="#", delimiter=" ", encoding="utf-8"):
         path.write(line.encode(encoding))
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_adjlist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None
 ):
@@ -224,7 +224,7 @@ def parse_adjlist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_adjlist(
     path,
     comments="#",
diff --git a/networkx/readwrite/edgelist.py b/networkx/readwrite/edgelist.py
index fcf6ec23013..ed445c80b42 100644
--- a/networkx/readwrite/edgelist.py
+++ b/networkx/readwrite/edgelist.py
@@ -173,7 +173,7 @@ def write_edgelist(G, path, comments="#", delimiter=" ", data=True, encoding="ut
         path.write(line.encode(encoding))
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_edgelist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
 ):
@@ -298,7 +298,7 @@ def parse_edgelist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_edgelist(
     path,
     comments="#",
@@ -425,7 +425,7 @@ def write_weighted_edgelist(G, path, comments="#", delimiter=" ", encoding="utf-
     )
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_weighted_edgelist(
     path,
     comments="#",
diff --git a/networkx/readwrite/gexf.py b/networkx/readwrite/gexf.py
index de444c5b31a..16b864377bd 100644
--- a/networkx/readwrite/gexf.py
+++ b/networkx/readwrite/gexf.py
@@ -133,7 +133,7 @@ def generate_gexf(G, encoding="utf-8", prettyprint=True, version="1.2draft"):
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_gexf(path, node_type=None, relabel=False, version="1.2draft"):
     """Read graph in GEXF format from path.
 
diff --git a/networkx/readwrite/gml.py b/networkx/readwrite/gml.py
index f76fc204203..bec99154991 100644
--- a/networkx/readwrite/gml.py
+++ b/networkx/readwrite/gml.py
@@ -112,7 +112,7 @@ def literal_destringizer(rep):
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_gml(path, label="label", destringizer=None):
     """Read graph in GML format from `path`.
 
@@ -195,7 +195,7 @@ def filter_lines(lines):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_gml(lines, label="label", destringizer=None):
     """Parse GML graph from a string or iterable.
 
diff --git a/networkx/readwrite/graph6.py b/networkx/readwrite/graph6.py
index 06578e05ed6..5e2a30aa791 100644
--- a/networkx/readwrite/graph6.py
+++ b/networkx/readwrite/graph6.py
@@ -60,7 +60,7 @@ def _generate_graph6_bytes(G, nodes, header):
     yield b"\n"
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_graph6_bytes(bytes_in):
     """Read a simple undirected graph in graph6 format from bytes.
 
@@ -184,7 +184,7 @@ def to_graph6_bytes(G, nodes=None, header=True):
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_graph6(path):
     """Read simple undirected graphs in graph6 format from path.
 
diff --git a/networkx/readwrite/graphml.py b/networkx/readwrite/graphml.py
index 4de6ca1e882..3a9ab6a451a 100644
--- a/networkx/readwrite/graphml.py
+++ b/networkx/readwrite/graphml.py
@@ -233,7 +233,7 @@ def generate_graphml(
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_graphml(path, node_type=str, edge_key_type=int, force_multigraph=False):
     """Read graph in GraphML format from path.
 
@@ -306,7 +306,7 @@ def read_graphml(path, node_type=str, edge_key_type=int, force_multigraph=False)
     return glist[0]
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_graphml(
     graphml_string, node_type=str, edge_key_type=int, force_multigraph=False
 ):
diff --git a/networkx/readwrite/json_graph/adjacency.py b/networkx/readwrite/json_graph/adjacency.py
index 8fb24ea031b..3b05747565e 100644
--- a/networkx/readwrite/json_graph/adjacency.py
+++ b/networkx/readwrite/json_graph/adjacency.py
@@ -81,7 +81,7 @@ def adjacency_data(G, attrs=_attrs):
     return data
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def adjacency_graph(data, directed=False, multigraph=True, attrs=_attrs):
     """Returns graph from adjacency data format.
 
diff --git a/networkx/readwrite/json_graph/cytoscape.py b/networkx/readwrite/json_graph/cytoscape.py
index 8c45a020731..2f3b2176ab4 100644
--- a/networkx/readwrite/json_graph/cytoscape.py
+++ b/networkx/readwrite/json_graph/cytoscape.py
@@ -80,7 +80,7 @@ def cytoscape_data(G, name="name", ident="id"):
     return jsondata
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def cytoscape_graph(data, name="name", ident="id"):
     """
     Create a NetworkX graph from a dictionary in cytoscape JSON format.
diff --git a/networkx/readwrite/json_graph/node_link.py b/networkx/readwrite/json_graph/node_link.py
index e5136bad095..e29100f448a 100644
--- a/networkx/readwrite/json_graph/node_link.py
+++ b/networkx/readwrite/json_graph/node_link.py
@@ -132,7 +132,7 @@ def node_link_data(
     return data
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def node_link_graph(
     data,
     directed=False,
diff --git a/networkx/readwrite/json_graph/tree.py b/networkx/readwrite/json_graph/tree.py
index bd8679fcab1..22b07b09d27 100644
--- a/networkx/readwrite/json_graph/tree.py
+++ b/networkx/readwrite/json_graph/tree.py
@@ -83,7 +83,7 @@ def add_children(n, G):
     return {**G.nodes[root], ident: root, children: add_children(root, G)}
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def tree_graph(data, ident="id", children="children"):
     """Returns graph from tree data format.
 
diff --git a/networkx/readwrite/leda.py b/networkx/readwrite/leda.py
index d07162b65f3..9fb57db1400 100644
--- a/networkx/readwrite/leda.py
+++ b/networkx/readwrite/leda.py
@@ -19,7 +19,7 @@
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_leda(path, encoding="UTF-8"):
     """Read graph in LEDA format from path.
 
@@ -46,7 +46,7 @@ def read_leda(path, encoding="UTF-8"):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_leda(lines):
     """Read graph in LEDA format from string or iterable.
 
diff --git a/networkx/readwrite/multiline_adjlist.py b/networkx/readwrite/multiline_adjlist.py
index fe542e6a1fd..526b30a9b05 100644
--- a/networkx/readwrite/multiline_adjlist.py
+++ b/networkx/readwrite/multiline_adjlist.py
@@ -191,7 +191,7 @@ def write_multiline_adjlist(G, path, delimiter=" ", comments="#", encoding="utf-
         path.write(multiline.encode(encoding))
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_multiline_adjlist(
     lines, comments="#", delimiter=None, create_using=None, nodetype=None, edgetype=None
 ):
@@ -301,7 +301,7 @@ def parse_multiline_adjlist(
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_multiline_adjlist(
     path,
     comments="#",
diff --git a/networkx/readwrite/p2g.py b/networkx/readwrite/p2g.py
index 2afba8c6f4d..85f07ec8415 100644
--- a/networkx/readwrite/p2g.py
+++ b/networkx/readwrite/p2g.py
@@ -57,7 +57,7 @@ def write_p2g(G, path, encoding="utf-8"):
 
 
 @open_file(0, mode="r")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_p2g(path, encoding="utf-8"):
     """Read graph in p2g format from path.
 
@@ -75,7 +75,7 @@ def read_p2g(path, encoding="utf-8"):
     return G
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_p2g(lines):
     """Parse p2g format graph from string or iterable.
 
diff --git a/networkx/readwrite/pajek.py b/networkx/readwrite/pajek.py
index fef19408001..f148f16208d 100644
--- a/networkx/readwrite/pajek.py
+++ b/networkx/readwrite/pajek.py
@@ -130,7 +130,7 @@ def write_pajek(G, path, encoding="UTF-8"):
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_pajek(path, encoding="UTF-8"):
     """Read graph in Pajek format from path.
 
@@ -163,7 +163,7 @@ def read_pajek(path, encoding="UTF-8"):
     return parse_pajek(lines)
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def parse_pajek(lines):
     """Parse Pajek format graph from string or iterable.
 
diff --git a/networkx/readwrite/sparse6.py b/networkx/readwrite/sparse6.py
index 04fe9e6edc6..a7059943895 100644
--- a/networkx/readwrite/sparse6.py
+++ b/networkx/readwrite/sparse6.py
@@ -101,7 +101,7 @@ def enc(x):
     yield b"\n"
 
 
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def from_sparse6_bytes(string):
     """Read an undirected graph in sparse6 format from string.
 
@@ -250,7 +250,7 @@ def to_sparse6_bytes(G, nodes=None, header=True):
 
 
 @open_file(0, mode="rb")
-@nx._dispatchable(graphs=None)
+@nx._dispatchable(graphs=None, returns_graph=True)
 def read_sparse6(path):
     """Read an undirected graph in sparse6 format from path.
 
diff --git a/networkx/relabel.py b/networkx/relabel.py
index 6e5f805d9ba..4b870f726ef 100644
--- a/networkx/relabel.py
+++ b/networkx/relabel.py
@@ -3,7 +3,9 @@
 __all__ = ["convert_node_labels_to_integers", "relabel_nodes"]
 
 
-@nx._dispatchable(preserve_all_attrs=True)
+@nx._dispatchable(
+    preserve_all_attrs=True, mutates_input={"not copy": 2}, returns_graph=True
+)
 def relabel_nodes(G, mapping, copy=True):
     """Relabel the nodes of the graph G according to a given mapping.
 
@@ -221,9 +223,7 @@ def _relabel_copy(G, mapping):
     return H
 
 
-@nx._dispatchable(
-    preserve_edge_attrs=True, preserve_node_attrs=True, preserve_graph_attrs=True
-)
+@nx._dispatchable(preserve_all_attrs=True, returns_graph=True)
 def convert_node_labels_to_integers(
     G, first_label=0, ordering="default", label_attribute=None
 ):
diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 8dfb82496de..8a0e127caa8 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -179,6 +179,8 @@ def __new__(
         preserve_node_attrs=False,
         preserve_graph_attrs=False,
         preserve_all_attrs=False,
+        mutates_input=False,
+        returns_graph=False,
     ):
         """Dispatches to a backend algorithm based on input graph types.
 
@@ -236,6 +238,18 @@ def __new__(
             Whether to preserve all edge, node and graph attributes.
             This overrides all the other preserve_*_attrs.
 
+        mutates_input : bool or dict, default False
+            For bool, whether the functions mutates an input graph argument.
+            For dict of ``{arg_name: arg_pos}``, arguments that indicates whether an
+            input graph will be mutated, and ``arg_name`` may begin with ``"not "``
+            to negate the logic (for example, this is used by ``copy=`` arguments).
+            By default, dispatching doesn't convert input graphs to a different
+            backend for functions that mutate input graphs.
+
+        returns_graph : bool, default False
+            Whether the function can return or yield a graph object. By default,
+            dispatching doesn't convert input graphs to a different backend for
+            functions that return graphs.
         """
         if func is None:
             return partial(
@@ -248,6 +262,8 @@ def __new__(
                 preserve_node_attrs=preserve_node_attrs,
                 preserve_graph_attrs=preserve_graph_attrs,
                 preserve_all_attrs=preserve_all_attrs,
+                mutates_input=mutates_input,
+                returns_graph=returns_graph,
             )
         if isinstance(func, str):
             raise TypeError("'name' and 'graphs' must be passed by keyword") from None
@@ -283,6 +299,9 @@ def __new__(
         self.preserve_edge_attrs = preserve_edge_attrs or preserve_all_attrs
         self.preserve_node_attrs = preserve_node_attrs or preserve_all_attrs
         self.preserve_graph_attrs = preserve_graph_attrs or preserve_all_attrs
+        self.mutates_input = mutates_input
+        # Keep `returns_graph` private for now, b/c we may extend info on return types
+        self._returns_graph = returns_graph
 
         if edge_attrs is not None and not isinstance(edge_attrs, str | dict):
             raise TypeError(
@@ -307,6 +326,16 @@ def __new__(
                 f"Bad type for preserve_graph_attrs: {type(self.preserve_graph_attrs)}."
                 " Expected bool or set."
             ) from None
+        if not isinstance(self.mutates_input, bool | dict):
+            raise TypeError(
+                f"Bad type for mutates_input: {type(self.mutates_input)}."
+                " Expected bool or dict."
+            ) from None
+        if not isinstance(self._returns_graph, bool):
+            raise TypeError(
+                f"Bad type for returns_graph: {type(self._returns_graph)}."
+                " Expected bool."
+            ) from None
 
         if isinstance(graphs, str):
             graphs = {graphs: 0}
@@ -445,15 +474,6 @@ def __call__(self, /, *args, backend=None, **kwargs):
         #     if (val := args[pos] if pos < len(args) else kwargs.get(gname)) is not None
         # }
 
-        if self._is_testing and self._automatic_backends and backend_name is None:
-            # Special path if we are running networkx tests with a backend.
-            return self._convert_and_call_for_tests(
-                self._automatic_backends[0],
-                args,
-                kwargs,
-                fallback_to_nx=self._fallback_to_nx,
-            )
-
         # Check if any graph comes from a backend
         if self.list_graphs:
             # Make sure we don't lose values by consuming an iterator
@@ -492,6 +512,17 @@ def __call__(self, /, *args, backend=None, **kwargs):
                     getattr(g, "__networkx_backend__", "networkx")
                     for g in graphs_resolved.values()
                 }
+
+        if self._is_testing and self._automatic_backends and backend_name is None:
+            # Special path if we are running networkx tests with a backend.
+            # This even runs for (and handles) functions that mutate input graphs.
+            return self._convert_and_call_for_tests(
+                self._automatic_backends[0],
+                args,
+                kwargs,
+                fallback_to_nx=self._fallback_to_nx,
+            )
+
         if has_backends:
             # Dispatchable graphs found! Dispatch to backend function.
             # We don't handle calls with different backend graphs yet,
@@ -524,7 +555,8 @@ def __call__(self, /, *args, backend=None, **kwargs):
             backend = _load_backend(graph_backend_name)
             if hasattr(backend, self.name):
                 if "networkx" in graph_backend_names:
-                    # We need to convert networkx graphs to backend graphs
+                    # We need to convert networkx graphs to backend graphs.
+                    # There is currently no need to check `self.mutates_input` here.
                     return self._convert_and_call(
                         graph_backend_name,
                         args,
@@ -545,8 +577,31 @@ def __call__(self, /, *args, backend=None, **kwargs):
             )
 
         # Only networkx graphs; try to convert and run with a backend with automatic
-        # conversion, but don't do this by default for graph generators or loaders.
-        if self.graphs:
+        # conversion, but don't do this by default for graph generators or loaders,
+        # or if the functions mutates an input graph or returns a graph.
+        if (
+            not self._returns_graph
+            and (
+                not self.mutates_input
+                or isinstance(self.mutates_input, dict)
+                # If `mutates_input` begins with "not ", then assume the argument is boolean,
+                # otherwise treat it as a node or edge attribute if it's not None.
+                and any(
+                    not (
+                        args[arg_pos]
+                        if len(args) > arg_pos
+                        else kwargs.get(arg_name[4:], True)
+                    )
+                    if arg_name.startswith("not ")
+                    else (
+                        args[arg_pos] if len(args) > arg_pos else kwargs.get(arg_name)
+                    )
+                    is not None
+                    for arg_name, arg_pos in self.mutates_input.items()
+                )
+            )
+        ):
+            # Should we warn or log if we don't convert b/c the input will be mutated?
             for backend_name in self._automatic_backends:
                 if self._can_backend_run(backend_name, *args, **kwargs):
                     return self._convert_and_call(
@@ -861,6 +916,40 @@ def _convert_and_call_for_tests(
             pytest.xfail(
                 exc.args[0] if exc.args else f"{self.name} raised {type(exc).__name__}"
             )
+        # Verify that `self._returns_graph` is correct. This compares the return type
+        # to the type expected from `self._returns_graph`. This handles tuple and list
+        # return types, but *does not* catch functions that yield graphs.
+        if (
+            self._returns_graph
+            != (
+                isinstance(result, nx.Graph)
+                or hasattr(result, "__networkx_backend__")
+                or isinstance(result, tuple | list)
+                and any(
+                    isinstance(x, nx.Graph) or hasattr(x, "__networkx_backend__")
+                    for x in result
+                )
+            )
+            and not (
+                # May return Graph or None
+                self.name in {"check_planarity", "check_planarity_recursive"}
+                and any(x is None for x in result)
+            )
+            and not (
+                # May return Graph or dict
+                self.name in {"held_karp_ascent"}
+                and any(isinstance(x, dict) for x in result)
+            )
+            and self.name
+            not in {
+                # yields graphs
+                "all_triads",
+                "general_k_edge_subgraphs",
+                # yields graphs or arrays
+                "nonisomorphic_trees",
+            }
+        ):
+            raise RuntimeError(f"`returns_graph` is incorrect for {self.name}")
 
         if self.name in {
             "edmonds_karp_core",

From 611cc9a250515f9a0d7e88adf25d46e3fffed35d Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Wed, 28 Feb 2024 06:55:37 -0800
Subject: [PATCH 084/129] Deprecate the `create` argument of
 `nonisomorphic_trees` (#7316)

* Add deprecation warning and docstring warning.

* Add deprecated_call to tests.

* Add warnings filter to test conf.

* Add note to deprecation docs.
---
 doc/developer/deprecations.rst                |  2 ++
 networkx/conftest.py                          |  3 +++
 networkx/generators/nonisomorphic_trees.py    | 23 +++++++++++++++++++
 .../tests/test_nonisomorphic_trees.py         | 17 ++++++++------
 4 files changed, 38 insertions(+), 7 deletions(-)

diff --git a/doc/developer/deprecations.rst b/doc/developer/deprecations.rst
index fffe9ecef2f..099d47cd419 100644
--- a/doc/developer/deprecations.rst
+++ b/doc/developer/deprecations.rst
@@ -70,3 +70,5 @@ Version 3.5
   to return a dict. See #6527
 * Change ``shortest_path`` in ``algorithms/shortest_path/generic.py``
   to return a iterator. See #6527
+* Remove ``create`` keyword argument from ``nonisomorphic_trees`` in 
+  ``generators/nonisomorphic_trees``.
diff --git a/networkx/conftest.py b/networkx/conftest.py
index 1f045517575..20894e2aded 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -148,6 +148,9 @@ def set_warnings():
     warnings.filterwarnings(
         "ignore", category=DeprecationWarning, message="\n\nk_corona"
     )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message=r"\n\nThe 'create=matrix'"
+    )
 
 
 @pytest.fixture(autouse=True)
diff --git a/networkx/generators/nonisomorphic_trees.py b/networkx/generators/nonisomorphic_trees.py
index 9d403cb848e..9716cf33834 100644
--- a/networkx/generators/nonisomorphic_trees.py
+++ b/networkx/generators/nonisomorphic_trees.py
@@ -25,6 +25,15 @@ def nonisomorphic_trees(order, create="graph"):
        If ``"graph"`` is selected a list of ``Graph`` instances will be returned,
        if matrix is selected a list of adjacency matrices will be returned.
 
+       .. deprecated:: 3.3
+
+          The `create` argument is deprecated and will be removed in NetworkX
+          version 3.5. In the future, `nonisomorphic_trees` will yield graph
+          instances by default. To generate adjacency matrices, call
+          ``nx.to_numpy_array`` on the output, e.g.::
+
+             [nx.to_numpy_array(G) for G in nx.nonisomorphic_trees(N)]
+
     Yields
     ------
     list
@@ -45,6 +54,20 @@ def nonisomorphic_trees(order, create="graph"):
             if create == "graph":
                 yield _layout_to_graph(layout)
             elif create == "matrix":
+                import warnings
+
+                warnings.warn(
+                    (
+                        "\n\nThe 'create=matrix' argument of nonisomorphic_trees\n"
+                        "is deprecated and will be removed in version 3.5.\n"
+                        "Use ``nx.to_numpy_array`` to convert graphs to adjacency "
+                        "matrices, e.g.::\n\n"
+                        "   [nx.to_numpy_array(G) for G in nx.nonisomorphic_trees(N)]"
+                    ),
+                    category=DeprecationWarning,
+                    stacklevel=2,
+                )
+
                 yield _layout_to_matrix(layout)
             layout = _next_rooted_tree(layout)
 
diff --git a/networkx/generators/tests/test_nonisomorphic_trees.py b/networkx/generators/tests/test_nonisomorphic_trees.py
index ced1cbe15c9..f654eac8841 100644
--- a/networkx/generators/tests/test_nonisomorphic_trees.py
+++ b/networkx/generators/tests/test_nonisomorphic_trees.py
@@ -1,10 +1,8 @@
 """
-====================
-Generators - Non Isomorphic Trees
-====================
-
 Unit tests for WROM algorithm generator in generators/nonisomorphic_trees.py
 """
+import pytest
+
 import networkx as nx
 from networkx.utils import edges_equal
 
@@ -54,11 +52,16 @@ def f(x):
 
     def test_nonisomorphic_trees_matrix(self):
         trees_2 = [[[0, 1], [1, 0]]]
-        assert list(nx.nonisomorphic_trees(2, create="matrix")) == trees_2
+        with pytest.deprecated_call():
+            assert list(nx.nonisomorphic_trees(2, create="matrix")) == trees_2
+
         trees_3 = [[[0, 1, 1], [1, 0, 0], [1, 0, 0]]]
-        assert list(nx.nonisomorphic_trees(3, create="matrix")) == trees_3
+        with pytest.deprecated_call():
+            assert list(nx.nonisomorphic_trees(3, create="matrix")) == trees_3
+
         trees_4 = [
             [[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]],
             [[0, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]],
         ]
-        assert list(nx.nonisomorphic_trees(4, create="matrix")) == trees_4
+        with pytest.deprecated_call():
+            assert list(nx.nonisomorphic_trees(4, create="matrix")) == trees_4

From f5ada3f9df4273e7fca8e6b393a61afe8d6507a4 Mon Sep 17 00:00:00 2001
From: Mauricio Souza de Alencar <856825+mdealencar@users.noreply.github.com>
Date: Wed, 28 Feb 2024 15:59:34 +0100
Subject: [PATCH 085/129] fix: make `PlanarEmbedding.copy()` use
 `add_edges_from()` from parent (closes #7223) (#7224)

fix: make `PlanarEmbedding.copy()` use `add_edges_from()` from parent class (planarity.py)
---
 networkx/algorithms/planarity.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/networkx/algorithms/planarity.py b/networkx/algorithms/planarity.py
index cfbb36a5c5e..b8dcda60c83 100644
--- a/networkx/algorithms/planarity.py
+++ b/networkx/algorithms/planarity.py
@@ -1385,3 +1385,16 @@ def is_directed(self):
         contained.
         """
         return False
+
+    def copy(self, as_view=False):
+        if as_view is True:
+            return nx.graphviews.generic_graph_view(self)
+        G = self.__class__()
+        G.graph.update(self.graph)
+        G.add_nodes_from((n, d.copy()) for n, d in self._node.items())
+        super(self.__class__, G).add_edges_from(
+            (u, v, datadict.copy())
+            for u, nbrs in self._adj.items()
+            for v, datadict in nbrs.items()
+        )
+        return G

From 26cbde337f65301faa03037eea2825cce4a43414 Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Wed, 28 Feb 2024 13:57:13 -0600
Subject: [PATCH 086/129] Add explicit targets of missing modules for
 intersphinx (#7313)

---
 doc/reference/algorithms/assortativity.rst |  8 +++++
 doc/reference/algorithms/centrality.rst    | 34 ++++++++++++++++++++++
 doc/reference/algorithms/coloring.rst      |  3 ++
 doc/reference/algorithms/community.rst     |  2 +-
 doc/reference/algorithms/component.rst     | 12 ++++++++
 doc/reference/algorithms/flow.rst          | 11 +++++++
 doc/reference/algorithms/isomorphism.rst   |  1 +
 doc/reference/algorithms/minors.rst        |  2 ++
 doc/reference/readwrite/json_graph.rst     |  5 ++++
 9 files changed, 77 insertions(+), 1 deletion(-)

diff --git a/doc/reference/algorithms/assortativity.rst b/doc/reference/algorithms/assortativity.rst
index 8ec61677661..a6afe231e6a 100644
--- a/doc/reference/algorithms/assortativity.rst
+++ b/doc/reference/algorithms/assortativity.rst
@@ -6,6 +6,8 @@ Assortativity
 .. autosummary::
    :toctree: generated/
 
+.. _networkx.algorithms.assortativity.correlation:
+
 Assortativity
 -------------
 .. autosummary::
@@ -16,6 +18,8 @@ Assortativity
    numeric_assortativity_coefficient
    degree_pearson_correlation_coefficient
 
+.. _networkx.algorithms.assortativity.neighbor_degree:
+
 Average neighbor degree
 -----------------------
 .. autosummary::
@@ -23,6 +27,7 @@ Average neighbor degree
 
    average_neighbor_degree
 
+.. _networkx.algorithms.assortativity.connectivity:
 
 Average degree connectivity
 ---------------------------
@@ -31,6 +36,7 @@ Average degree connectivity
 
    average_degree_connectivity
 
+.. _networkx.algorithms.assortativity.mixing:
 
 Mixing
 ------
@@ -43,6 +49,8 @@ Mixing
    degree_mixing_dict
    mixing_dict
 
+.. _networkx.algorithms.assortativity.pairs:
+
 Pairs
 -----
 .. autosummary::
diff --git a/doc/reference/algorithms/centrality.rst b/doc/reference/algorithms/centrality.rst
index b7d4001746f..b0ea8437530 100644
--- a/doc/reference/algorithms/centrality.rst
+++ b/doc/reference/algorithms/centrality.rst
@@ -4,6 +4,8 @@ Centrality
 
 .. automodule:: networkx.algorithms.centrality
 
+.. _networkx.algorithms.centrality.degree_alg:
+
 Degree
 ------
 .. autosummary::
@@ -13,6 +15,9 @@ Degree
    in_degree_centrality
    out_degree_centrality
 
+.. _networkx.algorithms.centrality.eigenvector:
+.. _networkx.algorithms.centrality.katz:
+
 Eigenvector
 -----------
 .. autosummary::
@@ -23,6 +28,8 @@ Eigenvector
    katz_centrality
    katz_centrality_numpy
 
+.. _networkx.algorithms.centrality.closeness:
+
 Closeness
 ---------
 .. autosummary::
@@ -31,6 +38,8 @@ Closeness
    closeness_centrality
    incremental_closeness_centrality
 
+.. _networkx.algorithms.centrality.current_flow_closeness:
+
 Current Flow Closeness
 ----------------------
 .. autosummary::
@@ -39,6 +48,9 @@ Current Flow Closeness
    current_flow_closeness_centrality
    information_centrality
 
+.. _networkx.algorithms.centrality.betweenness:
+.. _networkx.algorithms.centrality.betweenness_subset:
+
 (Shortest Path) Betweenness
 ---------------------------
 .. autosummary::
@@ -49,6 +61,8 @@ Current Flow Closeness
    edge_betweenness_centrality
    edge_betweenness_centrality_subset
 
+.. _networkx.algorithms.centrality.current_flow_betweenness:
+.. _networkx.algorithms.centrality.current_flow_betweenness_subset:
 
 Current Flow Betweenness
 ------------------------
@@ -68,6 +82,8 @@ Communicability Betweenness
 
    communicability_betweenness_centrality
 
+.. _networkx.algorithms.centrality.group:
+
 Group Centrality
 ----------------
 .. autosummary::
@@ -80,6 +96,8 @@ Group Centrality
    group_out_degree_centrality
    prominent_group
 
+.. _networkx.algorithms.centrality.load:
+
 Load
 ----
 .. autosummary::
@@ -88,6 +106,8 @@ Load
    load_centrality
    edge_load_centrality
 
+.. _networkx.algorithms.centrality.subgraph_alg:
+
 Subgraph
 --------
 .. autosummary::
@@ -97,6 +117,8 @@ Subgraph
    subgraph_centrality_exp
    estrada_index
 
+.. _networkx.algorithms.centrality.harmonic:
+
 Harmonic Centrality
 -------------------
 .. autosummary::
@@ -111,6 +133,8 @@ Dispersion
 
    dispersion
 
+.. _networkx.algorithms.centrality.reaching:
+
 Reaching
 --------
 .. autosummary::
@@ -119,6 +143,8 @@ Reaching
    local_reaching_centrality
    global_reaching_centrality
 
+.. _networkx.algorithms.centrality.percolation:
+
 Percolation
 -----------
 .. autosummary::
@@ -126,6 +152,8 @@ Percolation
 
    percolation_centrality
 
+.. _networkx.algorithms.centrality.second_order:
+
 Second Order Centrality
 -----------------------
 .. autosummary::
@@ -133,6 +161,8 @@ Second Order Centrality
 
    second_order_centrality
 
+.. _networkx.algorithms.centrality.trophic:
+
 Trophic
 -------
 .. autosummary::
@@ -142,6 +172,8 @@ Trophic
    trophic_differences
    trophic_incoherence_parameter
 
+.. _networkx.algorithms.centrality.voterank_alg:
+
 VoteRank
 --------
 .. autosummary::
@@ -149,6 +181,8 @@ VoteRank
 
    voterank
 
+.. _networkx.algorithms.centrality.laplacian:
+
 Laplacian
 ---------
 .. autosummary::
diff --git a/doc/reference/algorithms/coloring.rst b/doc/reference/algorithms/coloring.rst
index a0e68ce769f..5c21770d528 100644
--- a/doc/reference/algorithms/coloring.rst
+++ b/doc/reference/algorithms/coloring.rst
@@ -1,3 +1,6 @@
+.. _networkx.algorithms.coloring.greedy_coloring:
+.. _networkx.algorithms.coloring.equitable_coloring:
+
 ********
 Coloring
 ********
diff --git a/doc/reference/algorithms/community.rst b/doc/reference/algorithms/community.rst
index b031bcb349b..0c62bf5bb13 100644
--- a/doc/reference/algorithms/community.rst
+++ b/doc/reference/algorithms/community.rst
@@ -15,7 +15,7 @@ Bipartitions
    kernighan_lin_bisection
 
 Divisive Communities
----------------------
+--------------------
 .. automodule:: networkx.algorithms.community.divisive
 .. autosummary::
    :toctree: generated/
diff --git a/doc/reference/algorithms/component.rst b/doc/reference/algorithms/component.rst
index 23aa4c5bcf2..a0b25d1de6e 100644
--- a/doc/reference/algorithms/component.rst
+++ b/doc/reference/algorithms/component.rst
@@ -3,6 +3,8 @@ Components
 **********
 .. automodule:: networkx.algorithms.components
 
+.. _networkx.algorithms.components.connected:
+
 Connectivity
 ------------
 .. autosummary::
@@ -13,6 +15,8 @@ Connectivity
    connected_components
    node_connected_component
 
+.. _networkx.algorithms.components.strongly_connected:
+
 Strong connectivity
 -------------------
 .. autosummary::
@@ -25,6 +29,8 @@ Strong connectivity
    kosaraju_strongly_connected_components
    condensation
 
+.. _networkx.algorithms.components.weakly_connected:
+
 Weak connectivity
 -----------------
 .. autosummary::
@@ -34,6 +40,8 @@ Weak connectivity
    number_weakly_connected_components
    weakly_connected_components
 
+.. _networkx.algorithms.components.attracting:
+
 Attracting components
 ---------------------
 .. autosummary::
@@ -43,6 +51,8 @@ Attracting components
    number_attracting_components
    attracting_components
 
+.. _networkx.algorithms.components.biconnected:
+
 Biconnected components
 ----------------------
 .. autosummary::
@@ -53,6 +63,8 @@ Biconnected components
    biconnected_component_edges
    articulation_points
 
+.. _networkx.algorithms.components.semiconnected:
+
 Semiconnectedness
 -----------------
 .. autosummary::
diff --git a/doc/reference/algorithms/flow.rst b/doc/reference/algorithms/flow.rst
index 0888f052c7e..8fe2936fee7 100644
--- a/doc/reference/algorithms/flow.rst
+++ b/doc/reference/algorithms/flow.rst
@@ -4,6 +4,7 @@ Flows
 
 .. automodule:: networkx.algorithms.flow
 
+.. _networkx.algorithms.flow.maxflow:
 
 Maximum Flow
 ------------
@@ -15,6 +16,7 @@ Maximum Flow
    minimum_cut
    minimum_cut_value
 
+.. _networkx.algorithms.flow.edmondskarp:
 
 Edmonds-Karp
 ------------
@@ -23,6 +25,7 @@ Edmonds-Karp
 
    edmonds_karp
 
+.. _networkx.algorithms.flow.shortestaugmentingpath:
 
 Shortest Augmenting Path
 ------------------------
@@ -31,6 +34,7 @@ Shortest Augmenting Path
 
    shortest_augmenting_path
 
+.. _networkx.algorithms.flow.preflowpush:
 
 Preflow-Push
 ------------
@@ -39,6 +43,7 @@ Preflow-Push
 
    preflow_push
 
+.. _networkx.algorithms.flow.dinitz_alg:
 
 Dinitz
 ------
@@ -47,6 +52,7 @@ Dinitz
 
    dinitz
 
+.. _networkx.algorithms.flow.boykovkolmogorov:
 
 Boykov-Kolmogorov
 -----------------
@@ -55,6 +61,7 @@ Boykov-Kolmogorov
 
    boykov_kolmogorov
 
+.. _networkx.algorithms.flow.gomory_hu:
 
 Gomory-Hu Tree
 --------------
@@ -63,6 +70,7 @@ Gomory-Hu Tree
 
    gomory_hu_tree
 
+.. _networkx.algorithms.flow.utils:
 
 Utils
 -----
@@ -71,6 +79,8 @@ Utils
 
    build_residual_network
 
+.. _networkx.algorithms.flow.mincost:
+.. _networkx.algorithms.flow.networksimplex:
 
 Network Simplex
 ---------------
@@ -83,6 +93,7 @@ Network Simplex
     cost_of_flow
     max_flow_min_cost
 
+.. _networkx.algorithms.flow.capacityscaling:
 
 Capacity Scaling Minimum Cost Flow
 ----------------------------------
diff --git a/doc/reference/algorithms/isomorphism.rst b/doc/reference/algorithms/isomorphism.rst
index 1d64bd0e7f8..2010831c514 100644
--- a/doc/reference/algorithms/isomorphism.rst
+++ b/doc/reference/algorithms/isomorphism.rst
@@ -1,4 +1,5 @@
 .. _isomorphism:
+.. _networkx.algorithms.isomorphism.isomorph:
 
 ***********
 Isomorphism
diff --git a/doc/reference/algorithms/minors.rst b/doc/reference/algorithms/minors.rst
index 77cf7385e96..cfe6677d3b5 100644
--- a/doc/reference/algorithms/minors.rst
+++ b/doc/reference/algorithms/minors.rst
@@ -1,3 +1,5 @@
+.. _networkx.algorithms.minors.contraction:
+
 ******
 Minors
 ******
diff --git a/doc/reference/readwrite/json_graph.rst b/doc/reference/readwrite/json_graph.rst
index 53368770ed4..2fed0804948 100644
--- a/doc/reference/readwrite/json_graph.rst
+++ b/doc/reference/readwrite/json_graph.rst
@@ -1,3 +1,8 @@
+.. _networkx.readwrite.json_graph.adjacency:
+.. _networkx.readwrite.json_graph.cytoscape:
+.. _networkx.readwrite.json_graph.node_link:
+.. _networkx.readwrite.json_graph.tree:
+
 JSON
 ====
 .. automodule:: networkx.readwrite.json_graph

From 051ffc1f75d63ff685141e8afc131a0e03325091 Mon Sep 17 00:00:00 2001
From: Dan Schult <dschult@colgate.edu>
Date: Wed, 28 Feb 2024 15:03:49 -0500
Subject: [PATCH 087/129] Allow seed of np.random instance to exactly produce
 arbitrarily large integers (#6869)

* Allow numpy.random to produce arbitrary integers

- Introduce PythonRandomViaNumpyBits to replace PythonRandomInterface
  Follows Robert Kern suggestion in Numpy Issue #244858
- set up to use old interface for possible Legacy users
  (RandomState that isn't the default RandomState)
  All others users dont have claim to maintain the stream
- set up other input to provide new interface
- rewrite old interface to not raise when high limit is > int64 value
- Update decorator doc_strings to reflect numpy.random.Generators
- shift to `random()` from `random_sample()`
- correct the broken tests in test_decorators (assert a,b => assert a==b
- add decorator tests for numpy Generator class
- add smoke test of requesting very large int even with old interface
- update tests of create_py_random_state to reflect changes

* handle randrange default corner case
---
 networkx/utils/decorators.py            |  30 +++---
 networkx/utils/misc.py                  | 127 ++++++++++++++++++++----
 networkx/utils/tests/test_decorators.py |  59 +++++++----
 networkx/utils/tests/test_misc.py       |  26 +++--
 4 files changed, 185 insertions(+), 57 deletions(-)

diff --git a/networkx/utils/decorators.py b/networkx/utils/decorators.py
index ea37a506e19..205bf500543 100644
--- a/networkx/utils/decorators.py
+++ b/networkx/utils/decorators.py
@@ -267,14 +267,15 @@ def _nodes_or_number(n):
 
 
 def np_random_state(random_state_argument):
-    """Decorator to generate a `numpy.random.RandomState` instance.
+    """Decorator to generate a numpy RandomState or Generator instance.
 
     The decorator processes the argument indicated by `random_state_argument`
     using :func:`nx.utils.create_random_state`.
     The argument value can be a seed (integer), or a `numpy.random.RandomState`
-    instance or (`None` or `numpy.random`). The latter options use the glocal
-    random number generator used by `numpy.random`.
-    The result is a `numpy.random.RandomState` instance.
+    or `numpy.random.RandomState` instance or (`None` or `numpy.random`).
+    The latter two options use the global random number generator for `numpy.random`.
+
+    The returned instance is a `numpy.random.RandomState` or `numpy.random.Generator`.
 
     Parameters
     ----------
@@ -315,19 +316,24 @@ def random_array(dims, random_state=1):
 def py_random_state(random_state_argument):
     """Decorator to generate a random.Random instance (or equiv).
 
-    The decorator processes the argument indicated by `random_state_argument`
-    using :func:`nx.utils.create_py_random_state`.
-    The argument value can be a seed (integer), or a random number generator::
+    This decorator processes `random_state_argument` using
+    :func:`nx.utils.create_py_random_state`.
+    The input value can be a seed (integer), or a random number generator::
 
         If int, return a random.Random instance set with seed=int.
         If random.Random instance, return it.
         If None or the `random` package, return the global random number
         generator used by `random`.
-        If np.random package, return the global numpy random number
-        generator wrapped in a PythonRandomInterface class.
-        If np.random.RandomState instance, return it wrapped in
-        PythonRandomInterface
-        If a PythonRandomInterface instance, return it
+        If np.random package, or the default numpy RandomState instance,
+        return the default numpy random number generator wrapped in a
+        `PythonRandomViaNumpyBits`  class.
+        If np.random.Generator instance, return it wrapped in a
+        `PythonRandomViaNumpyBits`  class.
+
+        # Legacy options
+        If np.random.RandomState instance, return it wrapped in a
+        `PythonRandomInterface` class.
+        If a `PythonRandomInterface` instance, return it
 
     Parameters
     ----------
diff --git a/networkx/utils/misc.py b/networkx/utils/misc.py
index 54b9b17dcd6..6cc8707bd10 100644
--- a/networkx/utils/misc.py
+++ b/networkx/utils/misc.py
@@ -11,6 +11,7 @@
 1
 """
 
+import random
 import sys
 import uuid
 import warnings
@@ -30,6 +31,7 @@
     "create_random_state",
     "create_py_random_state",
     "PythonRandomInterface",
+    "PythonRandomViaNumpyBits",
     "nodes_equal",
     "edges_equal",
     "graphs_equal",
@@ -271,7 +273,68 @@ def create_random_state(random_state=None):
     raise ValueError(msg)
 
 
+class PythonRandomViaNumpyBits(random.Random):
+    """Provide the random.random algorithms using a Numpy.random bit generator
+
+    The intent is to allow people to contribute code that uses Python's random
+    library, but still allow users to provide a single easily controlled random
+    bit-stream for all work with NetworkX. This implementation is based on helpful
+    comments and code from Robert Kern on NumPy's GitHub Issue #24458.
+
+    This implementation supercedes that of `PythonRandomInterface` which rewrote
+    methods to account for subtle differences in API between `random` and
+    `numpy.random`. Instead this subclasses `random.Random` and overwrites
+    the methods `random`, `getrandbits`, `getstate`, `setstate` and `seed`.
+    It makes them use the rng values from an input numpy `RandomState` or `Generator`.
+    Those few methods allow the rest of the `random.Random` methods to provide
+    the API interface of `random.random` whlie using randomness generated by
+    a numpy generator.
+    """
+
+    def __init__(self, rng=None):
+        try:
+            import numpy as np
+        except ImportError:
+            msg = "numpy not found, only random.random available."
+            warnings.warn(msg, ImportWarning)
+
+        if rng is None:
+            self._rng = np.random.mtrand._rand
+        else:
+            self._rng = rng
+
+        # Not necessary, given our overriding of gauss() below, but it's
+        # in the superclass and nominally public, so initialize it here.
+        self.gauss_next = None
+
+    def random(self):
+        """Get the next random number in the range 0.0 <= X < 1.0."""
+        return self._rng.random()
+
+    def getrandbits(self, k):
+        """getrandbits(k) -> x.  Generates an int with k random bits."""
+        if k < 0:
+            raise ValueError("number of bits must be non-negative")
+        numbytes = (k + 7) // 8  # bits / 8 and rounded up
+        x = int.from_bytes(self._rng.bytes(numbytes), "big")
+        return x >> (numbytes * 8 - k)  # trim excess bits
+
+    def getstate(self):
+        return self._rng.__getstate__()
+
+    def setstate(self, state):
+        self._rng.__setstate__(state)
+
+    def seed(self, *args, **kwds):
+        "Do nothing override method."
+
+
+##################################################################
 class PythonRandomInterface:
+    """PythonRandomInterface is included for backward compatibility
+    New code should use PythonRandomViaNumpyBits instead.
+    """
+
     def __init__(self, rng=None):
         try:
             import numpy as np
@@ -293,6 +356,12 @@ def uniform(self, a, b):
     def randrange(self, a, b=None):
         import numpy as np
 
+        if b is None:
+            a, b = 0, a
+        if b > 9223372036854775807:  # from np.iinfo(np.int64).max
+            tmp_rng = PythonRandomViaNumpyBits(self._rng)
+            return tmp_rng.randrange(a, b)
+
         if isinstance(self._rng, np.random.Generator):
             return self._rng.integers(a, b)
         return self._rng.randint(a, b)
@@ -323,6 +392,10 @@ def sample(self, seq, k):
     def randint(self, a, b):
         import numpy as np
 
+        if b > 9223372036854775807:  # from np.iinfo(np.int64).max
+            tmp_rng = PythonRandomViaNumpyBits(self._rng)
+            return tmp_rng.randint(a, b)
+
         if isinstance(self._rng, np.random.Generator):
             return self._rng.integers(a, b + 1)
         return self._rng.randint(a, b + 1)
@@ -357,32 +430,50 @@ def create_py_random_state(random_state=None):
         if random.Random instance, return it.
         if None or the `random` package, return the global random number
         generator used by `random`.
-        if np.random package, return the global numpy random number
-        generator wrapped in a PythonRandomInterface class.
-        if np.random.RandomState or np.random.Generator instance, return it
-        wrapped in PythonRandomInterface
+        if an np.random.Generator instance, or the np.random package, or
+        the global numpy random number generator, then return it
+        wrapped in a PythonRandomViaNumpyBits class.
+        if a PythonRandomViaNumpyBits instance, return it
+
+        # Provided for backward bit-stream matching with legacy code
+        if a np.randomRandomState instance and not the global numpy default,
+        return it wrapped in PythonRandomInterface
         if a PythonRandomInterface instance, return it
-    """
-    import random
-
-    try:
-        import numpy as np
-
-        if random_state is np.random:
-            return PythonRandomInterface(np.random.mtrand._rand)
-        if isinstance(random_state, np.random.RandomState | np.random.Generator):
-            return PythonRandomInterface(random_state)
-        if isinstance(random_state, PythonRandomInterface):
-            return random_state
-    except ImportError:
-        pass
 
+    Note: Conversion from older PythonRandomInterface to PythonRandomViaNumpyBits
+    is handled here to allow users of Legacy `numpy.random.RandomState` to exactly
+    match the legacy values produced. We assume that if a user cares about legacy
+    values, they are using a np.RandomState instance that is not the numpy default.
+    The default instance has state reset for each Python session. The Generator
+    class does not guarantee to maintain bit stream across versions. We wrap any
+    RandomState instance other than the default with `PythonRandomInterface`.
+    All other numpy random inputs are wrapped with `PythonRandomViaNumpyBits`.
+    """
     if random_state is None or random_state is random:
         return random._inst
     if isinstance(random_state, random.Random):
         return random_state
     if isinstance(random_state, int):
         return random.Random(random_state)
+
+    try:
+        import numpy as np
+    except ImportError:
+        pass
+    else:
+        if isinstance(random_state, PythonRandomInterface | PythonRandomViaNumpyBits):
+            return random_state
+        if isinstance(random_state, np.random.Generator):
+            return PythonRandomViaNumpyBits(random_state)
+        if random_state is np.random:
+            return PythonRandomViaNumpyBits(np.random.mtrand._rand)
+
+        if isinstance(random_state, np.random.RandomState):
+            if random_state is np.random.mtrand._rand:
+                return PythonRandomViaNumpyBits(random_state)
+            # Only need older interface if specially constructed RandomState used
+            return PythonRandomInterface(random_state)
+
     msg = f"{random_state} cannot be used to generate a random.Random instance"
     raise ValueError(msg)
 
diff --git a/networkx/utils/tests/test_decorators.py b/networkx/utils/tests/test_decorators.py
index 01a0a8b4aef..0a4aeabfe0b 100644
--- a/networkx/utils/tests/test_decorators.py
+++ b/networkx/utils/tests/test_decorators.py
@@ -13,7 +13,7 @@
     open_file,
     py_random_state,
 )
-from networkx.utils.misc import PythonRandomInterface
+from networkx.utils.misc import PythonRandomInterface, PythonRandomViaNumpyBits
 
 
 def test_not_implemented_decorator():
@@ -212,17 +212,19 @@ def setup_class(cls):
 
     @np_random_state(1)
     def instantiate_np_random_state(self, random_state):
-        assert isinstance(random_state, np.random.RandomState)
-        return random_state.random_sample()
+        allowed = (np.random.RandomState, np.random.Generator)
+        assert isinstance(random_state, allowed)
+        return random_state.random()
 
     @py_random_state(1)
     def instantiate_py_random_state(self, random_state):
-        assert isinstance(random_state, random.Random | PythonRandomInterface)
+        allowed = (random.Random, PythonRandomInterface, PythonRandomViaNumpyBits)
+        assert isinstance(random_state, allowed)
         return random_state.random()
 
     def test_random_state_None(self):
         np.random.seed(42)
-        rv = np.random.random_sample()
+        rv = np.random.random()
         np.random.seed(42)
         assert rv == self.instantiate_np_random_state(None)
 
@@ -233,7 +235,7 @@ def test_random_state_None(self):
 
     def test_random_state_np_random(self):
         np.random.seed(42)
-        rv = np.random.random_sample()
+        rv = np.random.random()
         np.random.seed(42)
         assert rv == self.instantiate_np_random_state(np.random)
         np.random.seed(42)
@@ -241,7 +243,7 @@ def test_random_state_np_random(self):
 
     def test_random_state_int(self):
         np.random.seed(42)
-        np_rv = np.random.random_sample()
+        np_rv = np.random.random()
         random.seed(42)
         py_rv = random.random()
 
@@ -249,39 +251,56 @@ def test_random_state_int(self):
         seed = 1
         rval = self.instantiate_np_random_state(seed)
         rval_expected = np.random.RandomState(seed).rand()
-        assert rval, rval_expected
+        assert rval == rval_expected
         # test that global seed wasn't changed in function
-        assert np_rv == np.random.random_sample()
+        assert np_rv == np.random.random()
 
         random.seed(42)
         rval = self.instantiate_py_random_state(seed)
         rval_expected = random.Random(seed).random()
-        assert rval, rval_expected
+        assert rval == rval_expected
         # test that global seed wasn't changed in function
         assert py_rv == random.random()
 
-    def test_random_state_np_random_RandomState(self):
+    def test_random_state_np_random_Generator(self):
         np.random.seed(42)
-        np_rv = np.random.random_sample()
+        np_rv = np.random.random()
+        np.random.seed(42)
+        seed = 1
+
+        rng = np.random.default_rng(seed)
+        rval = self.instantiate_np_random_state(rng)
+        rval_expected = np.random.default_rng(seed).random()
+        assert rval == rval_expected
+
+        rval = self.instantiate_py_random_state(rng)
+        rval_expected = np.random.default_rng(seed).random(size=2)[1]
+        assert rval == rval_expected
+        # test that global seed wasn't changed in function
+        assert np_rv == np.random.random()
 
+    def test_random_state_np_random_RandomState(self):
+        np.random.seed(42)
+        np_rv = np.random.random()
         np.random.seed(42)
         seed = 1
+
         rng = np.random.RandomState(seed)
-        rval = self.instantiate_np_random_state(seed)
-        rval_expected = np.random.RandomState(seed).rand()
-        assert rval, rval_expected
+        rval = self.instantiate_np_random_state(rng)
+        rval_expected = np.random.RandomState(seed).random()
+        assert rval == rval_expected
 
-        rval = self.instantiate_py_random_state(seed)
-        rval_expected = np.random.RandomState(seed).rand()
-        assert rval, rval_expected
+        rval = self.instantiate_py_random_state(rng)
+        rval_expected = np.random.RandomState(seed).random(size=2)[1]
+        assert rval == rval_expected
         # test that global seed wasn't changed in function
-        assert np_rv == np.random.random_sample()
+        assert np_rv == np.random.random()
 
     def test_random_state_py_random(self):
         seed = 1
         rng = random.Random(seed)
         rv = self.instantiate_py_random_state(rng)
-        assert rv, random.Random(seed).random()
+        assert rv == random.Random(seed).random()
 
         pytest.raises(ValueError, self.instantiate_np_random_state, rng)
 
diff --git a/networkx/utils/tests/test_misc.py b/networkx/utils/tests/test_misc.py
index 38e9a0e5aa3..eff36b2a2f3 100644
--- a/networkx/utils/tests/test_misc.py
+++ b/networkx/utils/tests/test_misc.py
@@ -6,6 +6,7 @@
 import networkx as nx
 from networkx.utils import (
     PythonRandomInterface,
+    PythonRandomViaNumpyBits,
     arbitrary_element,
     create_py_random_state,
     create_random_state,
@@ -184,21 +185,31 @@ def test_create_py_random_state():
     rs = np.random.RandomState
     rng = np.random.default_rng(1000)
     rng_explicit = np.random.Generator(np.random.SFC64())
-    nprs = PythonRandomInterface
+    old_nprs = PythonRandomInterface
+    nprs = PythonRandomViaNumpyBits
     assert isinstance(create_py_random_state(np.random), nprs)
-    assert isinstance(create_py_random_state(rs(1)), nprs)
+    assert isinstance(create_py_random_state(rs(1)), old_nprs)
     assert isinstance(create_py_random_state(rng), nprs)
     assert isinstance(create_py_random_state(rng_explicit), nprs)
     # test default rng input
-    assert isinstance(PythonRandomInterface(), nprs)
+    assert isinstance(PythonRandomInterface(), old_nprs)
+    assert isinstance(PythonRandomViaNumpyBits(), nprs)
+
+    # VeryLargeIntegers Smoke test (they raise error for np.random)
+    int64max = 9223372036854775807  # from np.iinfo(np.int64).max
+    for r in (rng, rs(1)):
+        prs = create_py_random_state(r)
+        prs.randrange(3, int64max + 5)
+        prs.randint(3, int64max + 5)
 
 
 def test_PythonRandomInterface_RandomState():
     np = pytest.importorskip("numpy")
 
+    seed = 42
     rs = np.random.RandomState
-    rng = PythonRandomInterface(rs(42))
-    rs42 = rs(42)
+    rng = PythonRandomInterface(rs(seed))
+    rs42 = rs(seed)
 
     # make sure these functions are same as expected outcome
     assert rng.randrange(3, 5) == rs42.randint(3, 5)
@@ -219,8 +230,9 @@ def test_PythonRandomInterface_RandomState():
 def test_PythonRandomInterface_Generator():
     np = pytest.importorskip("numpy")
 
-    rng = np.random.default_rng(42)
-    pri = PythonRandomInterface(np.random.default_rng(42))
+    seed = 42
+    rng = np.random.default_rng(seed)
+    pri = PythonRandomInterface(np.random.default_rng(seed))
 
     # make sure these functions are same as expected outcome
     assert pri.randrange(3, 5) == rng.integers(3, 5)

From 5934f7ed080d7614fa727dc8bf84bf221e1c37d0 Mon Sep 17 00:00:00 2001
From: Dan Schult <dschult@colgate.edu>
Date: Fri, 1 Mar 2024 00:52:16 -0500
Subject: [PATCH 088/129] DOC: add doc suggestions for arbitrarily large random
 integers tools (#7322)

* follow up changes for arb large RNG

* fix webpage
---
 networkx/utils/misc.py | 57 ++++++++++++++++++++++++------------------
 1 file changed, 33 insertions(+), 24 deletions(-)

diff --git a/networkx/utils/misc.py b/networkx/utils/misc.py
index 6cc8707bd10..b8de5e5aa28 100644
--- a/networkx/utils/misc.py
+++ b/networkx/utils/misc.py
@@ -274,7 +274,7 @@ def create_random_state(random_state=None):
 
 
 class PythonRandomViaNumpyBits(random.Random):
-    """Provide the random.random algorithms using a Numpy.random bit generator
+    """Provide the random.random algorithms using a numpy.random bit generator
 
     The intent is to allow people to contribute code that uses Python's random
     library, but still allow users to provide a single easily controlled random
@@ -287,7 +287,7 @@ class PythonRandomViaNumpyBits(random.Random):
     the methods `random`, `getrandbits`, `getstate`, `setstate` and `seed`.
     It makes them use the rng values from an input numpy `RandomState` or `Generator`.
     Those few methods allow the rest of the `random.Random` methods to provide
-    the API interface of `random.random` whlie using randomness generated by
+    the API interface of `random.random` while using randomness generated by
     a numpy generator.
     """
 
@@ -327,6 +327,7 @@ def setstate(self, state):
 
     def seed(self, *args, **kwds):
         "Do nothing override method."
+        raise NotImplementedError("seed() not implemented in PythonRandomViaNumpyBits")
 
 
 ##################################################################
@@ -426,28 +427,36 @@ def create_py_random_state(random_state=None):
     Parameters
     ----------
     random_state : int or random number generator or None (default=None)
-        If int, return a random.Random instance set with seed=int.
-        if random.Random instance, return it.
-        if None or the `random` package, return the global random number
-        generator used by `random`.
-        if an np.random.Generator instance, or the np.random package, or
-        the global numpy random number generator, then return it
-        wrapped in a PythonRandomViaNumpyBits class.
-        if a PythonRandomViaNumpyBits instance, return it
-
-        # Provided for backward bit-stream matching with legacy code
-        if a np.randomRandomState instance and not the global numpy default,
-        return it wrapped in PythonRandomInterface
-        if a PythonRandomInterface instance, return it
-
-    Note: Conversion from older PythonRandomInterface to PythonRandomViaNumpyBits
-    is handled here to allow users of Legacy `numpy.random.RandomState` to exactly
-    match the legacy values produced. We assume that if a user cares about legacy
-    values, they are using a np.RandomState instance that is not the numpy default.
-    The default instance has state reset for each Python session. The Generator
-    class does not guarantee to maintain bit stream across versions. We wrap any
-    RandomState instance other than the default with `PythonRandomInterface`.
-    All other numpy random inputs are wrapped with `PythonRandomViaNumpyBits`.
+        - If int, return a `random.Random` instance set with seed=int.
+        - If `random.Random` instance, return it.
+        - If None or the `np.random` package, return the global random number
+          generator used by `np.random`.
+        - If an `np.random.Generator` instance, or the `np.random` package, or
+          the global numpy random number generator, then return it.
+          wrapped in a `PythonRandomViaNumpyBits` class.
+        - If a `PythonRandomViaNumpyBits` instance, return it.
+        - If a `PythonRandomInterface` instance, return it.
+        - If a `np.random.RandomState` instance and not the global numpy default,
+          return it wrapped in `PythonRandomInterface` for backward bit-stream
+          matching with legacy code.
+
+    Notes
+    -----
+    - A diagram intending to illustrate the relationships behind our support
+      for numpy random numbers is called
+      `NetworkX Numpy Random Numbers <https://excalidraw.com/#room=b5303f2b03d3af7ccc6a,e5ZDIWdWWCTTsg8OqoRvPA>`_.
+    - More discussion about this support also appears in
+      `gh-6869#comment <https://github.com/networkx/networkx/pull/6869#issuecomment-1944799534>`_.
+    - Wrappers of numpy.random number generators allow them to mimic the Python random
+      number generation algorithms. For example, Python can create arbitrarily large
+      random ints, and the wrappers use Numpy bit-streams with CPython's random module
+      to choose arbitrarily large random integers too.
+    - We provide two wrapper classes:
+      `PythonRandomViaNumpyBits` is usually what you want and is always used for
+      `np.Generator` instances. But for users who need to recreate random numbers
+      produced in NetworkX 3.2 or earlier, we maintain the `PythonRandomInterface`
+      wrapper as well. We use it only used if passed a (non-default) `np.RandomState`
+      instance pre-initialized from a seed. Otherwise the newer wrapper is used.
     """
     if random_state is None or random_state is random:
         return random._inst

From c339da9b0e3c54990624b2b2af7b97af7491eef8 Mon Sep 17 00:00:00 2001
From: Salim BELHADDAD <17280667+salym@users.noreply.github.com>
Date: Fri, 1 Mar 2024 06:57:49 +0100
Subject: [PATCH 089/129] Fix empty GraphML attribute is not parsed (#7319)

* Empty GraphML attribute is not parsed (main branche)

Fixes  #7291

networkx does not parse GraphML attributes that are empty.
This fix will create the attribute with an empty string.

* added test test_graphml.py

* minor changes (lint)
---
 networkx/readwrite/graphml.py            |  3 ++-
 networkx/readwrite/tests/test_graphml.py | 24 ++++++++++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/networkx/readwrite/graphml.py b/networkx/readwrite/graphml.py
index 3a9ab6a451a..7d4fd7a6673 100644
--- a/networkx/readwrite/graphml.py
+++ b/networkx/readwrite/graphml.py
@@ -1010,9 +1010,10 @@ def decode_data_elements(self, graphml_keys, obj_xml):
                     edge_label = data_element.find(f"{pref}EdgeLabel")
                     if edge_label is not None:
                         break
-
                 if edge_label is not None:
                     data["label"] = edge_label.text
+            elif text is None:
+                data[data_name] = ""
         return data
 
     def find_graphml_keys(self, graph_element):
diff --git a/networkx/readwrite/tests/test_graphml.py b/networkx/readwrite/tests/test_graphml.py
index 2d87026ae8a..5ffa837ea04 100644
--- a/networkx/readwrite/tests/test_graphml.py
+++ b/networkx/readwrite/tests/test_graphml.py
@@ -1505,3 +1505,27 @@ def test_exception_for_unsupported_datatype_graph_attr():
     fh = io.BytesIO()
     with pytest.raises(TypeError, match="GraphML does not support"):
         nx.write_graphml(G, fh)
+
+
+def test_empty_attribute():
+    """Tests that a GraphML string with an empty attribute can be parsed
+    correctly."""
+    s = """<?xml version='1.0' encoding='utf-8'?>
+    <graphml>
+      <key id="d1" for="node" attr.name="foo" attr.type="string"/>
+      <key id="d2" for="node" attr.name="bar" attr.type="string"/>
+      <graph>
+        <node id="0">
+          <data key="d1">aaa</data>
+          <data key="d2">bbb</data>
+        </node>
+        <node id="1">
+          <data key="d1">ccc</data>
+          <data key="d2"></data>
+        </node>
+      </graph>
+    </graphml>"""
+    fh = io.BytesIO(s.encode("UTF-8"))
+    G = nx.read_graphml(fh)
+    assert G.nodes["0"] == {"foo": "aaa", "bar": "bbb"}
+    assert G.nodes["1"] == {"foo": "ccc", "bar": ""}

From 28f3e9f61ee66e779b3475dfedc3e159344f4309 Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Fri, 1 Mar 2024 13:54:26 -0600
Subject: [PATCH 090/129] Avoid creating results with numpy scalars (re: NEP
 51) (#7282)

* Avoid creating results with numpy scalars (re: NEP 51)

* Revert changes to `convert_matrix.py` to see what happens

* Unrevert reversion

* Better

* respond to feedback: be more clear and use `x.item()`

* Use `a.item(i)` where appropriate
---
 .../algorithms/assortativity/correlation.py   |  6 +-
 .../algorithms/bipartite/extendability.py     |  3 +-
 networkx/algorithms/bipartite/spectral.py     |  4 +-
 .../centrality/current_flow_betweenness.py    | 38 ++++++------
 .../current_flow_betweenness_subset.py        | 28 ++++-----
 .../centrality/current_flow_closeness.py      | 18 +++---
 networkx/algorithms/centrality/eigenvector.py |  2 +-
 networkx/algorithms/centrality/katz.py        |  4 +-
 networkx/algorithms/centrality/laplacian.py   |  2 +-
 .../algorithms/centrality/second_order.py     |  5 +-
 .../algorithms/centrality/subgraph_alg.py     |  5 +-
 networkx/algorithms/centrality/trophic.py     |  4 +-
 networkx/algorithms/cluster.py                | 58 +++++++++----------
 networkx/algorithms/distance_measures.py      | 19 +++---
 networkx/algorithms/non_randomness.py         |  2 +-
 networkx/algorithms/shortest_paths/generic.py |  2 +-
 networkx/algorithms/similarity.py             | 15 ++---
 networkx/algorithms/smallworld.py             |  4 +-
 networkx/algorithms/walks.py                  |  2 +-
 networkx/conftest.py                          |  7 ---
 networkx/convert_matrix.py                    | 23 ++++----
 networkx/generators/classic.py                |  2 +-
 networkx/generators/expanders.py              |  3 +-
 networkx/linalg/algebraicconnectivity.py      |  8 +--
 networkx/linalg/laplacianmatrix.py            |  2 +-
 networkx/utils/backends.py                    | 48 ++++++++++++++-
 26 files changed, 181 insertions(+), 133 deletions(-)

diff --git a/networkx/algorithms/assortativity/correlation.py b/networkx/algorithms/assortativity/correlation.py
index c62e92f9c2e..170d219a5d4 100644
--- a/networkx/algorithms/assortativity/correlation.py
+++ b/networkx/algorithms/assortativity/correlation.py
@@ -156,7 +156,7 @@ def degree_pearson_correlation_coefficient(G, x="out", y="in", weight=None, node
 
     xy = node_degree_xy(G, x=x, y=y, nodes=nodes, weight=weight)
     x, y = zip(*xy)
-    return sp.stats.pearsonr(x, y)[0]
+    return float(sp.stats.pearsonr(x, y)[0])
 
 
 @nx._dispatchable(node_attrs="attribute")
@@ -280,7 +280,7 @@ def attribute_ac(M):
     s = (M @ M).sum()
     t = M.trace()
     r = (t - s) / (1 - s)
-    return r
+    return float(r)
 
 
 def _numeric_ac(M, mapping):
@@ -299,4 +299,4 @@ def _numeric_ac(M, mapping):
     varb = (b[idx] * y**2).sum() - ((b[idx] * y).sum()) ** 2
     xy = np.outer(x, y)
     ab = np.outer(a[idx], b[idx])
-    return (xy * (M - ab)).sum() / np.sqrt(vara * varb)
+    return float((xy * (M - ab)).sum() / np.sqrt(vara * varb))
diff --git a/networkx/algorithms/bipartite/extendability.py b/networkx/algorithms/bipartite/extendability.py
index 10dd5473b5c..0764997ad00 100644
--- a/networkx/algorithms/bipartite/extendability.py
+++ b/networkx/algorithms/bipartite/extendability.py
@@ -10,6 +10,7 @@
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
+@nx._dispatchable
 def maximal_extendability(G):
     """Computes the extendability of a graph.
 
@@ -97,7 +98,7 @@ def maximal_extendability(G):
 
     # For node-pairs between V & U, keep min of max number of node-disjoint paths
     # Variable $k$ stands for the extendability of graph G
-    k = float("Inf")
+    k = float("inf")
     for u in U:
         for v in V:
             num_paths = sum(1 for _ in nx.node_disjoint_paths(residual_G, u, v))
diff --git a/networkx/algorithms/bipartite/spectral.py b/networkx/algorithms/bipartite/spectral.py
index 0ecd283775f..61a56dd2c0e 100644
--- a/networkx/algorithms/bipartite/spectral.py
+++ b/networkx/algorithms/bipartite/spectral.py
@@ -57,12 +57,12 @@ def spectral_bipartivity(G, nodes=None, weight="weight"):
     coshA = 0.5 * (expA + expmA)
     if nodes is None:
         # return single number for entire graph
-        return coshA.diagonal().sum() / expA.diagonal().sum()
+        return float(coshA.diagonal().sum() / expA.diagonal().sum())
     else:
         # contribution for individual nodes
         index = dict(zip(nodelist, range(len(nodelist))))
         sb = {}
         for n in nodes:
             i = index[n]
-            sb[n] = coshA[i, i] / expA[i, i]
+            sb[n] = coshA.item(i, i) / expA.item(i, i)
         return sb
diff --git a/networkx/algorithms/centrality/current_flow_betweenness.py b/networkx/algorithms/centrality/current_flow_betweenness.py
index 9e68676b6a0..b79a4c801e8 100644
--- a/networkx/algorithms/centrality/current_flow_betweenness.py
+++ b/networkx/algorithms/centrality/current_flow_betweenness.py
@@ -134,7 +134,7 @@ def approximate_current_flow_betweenness_centrality(
                 continue
             for nbr in H[v]:
                 w = H[v][nbr].get(weight, 1.0)
-                betweenness[v] += w * np.abs(p[v] - p[nbr]) * cstar2k
+                betweenness[v] += float(w * np.abs(p[v] - p[nbr]) * cstar2k)
     if normalized:
         factor = 1.0
     else:
@@ -220,24 +220,22 @@ def current_flow_betweenness_centrality(
     """
     if not nx.is_connected(G):
         raise nx.NetworkXError("Graph not connected.")
-    n = G.number_of_nodes()
+    N = G.number_of_nodes()
     ordering = list(reverse_cuthill_mckee_ordering(G))
     # make a copy with integer labels according to rcm ordering
     # this could be done without a copy if we really wanted to
-    H = nx.relabel_nodes(G, dict(zip(ordering, range(n))))
-    betweenness = dict.fromkeys(H, 0.0)  # b[v]=0 for v in H
+    H = nx.relabel_nodes(G, dict(zip(ordering, range(N))))
+    betweenness = dict.fromkeys(H, 0.0)  # b[n]=0 for n in H
     for row, (s, t) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
-        pos = dict(zip(row.argsort()[::-1], range(n)))
-        for i in range(n):
-            betweenness[s] += (i - pos[i]) * row[i]
-            betweenness[t] += (n - i - 1 - pos[i]) * row[i]
+        pos = dict(zip(row.argsort()[::-1], range(N)))
+        for i in range(N):
+            betweenness[s] += (i - pos[i]) * row.item(i)
+            betweenness[t] += (N - i - 1 - pos[i]) * row.item(i)
     if normalized:
-        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+        nb = (N - 1.0) * (N - 2.0)  # normalization factor
     else:
         nb = 2.0
-    for v in H:
-        betweenness[v] = float((betweenness[v] - v) * 2.0 / nb)
-    return {ordering[k]: v for k, v in betweenness.items()}
+    return {ordering[n]: (b - n) * 2.0 / nb for n, b in betweenness.items()}
 
 
 @not_implemented_for("directed")
@@ -323,21 +321,21 @@ def edge_current_flow_betweenness_centrality(
     """
     if not nx.is_connected(G):
         raise nx.NetworkXError("Graph not connected.")
-    n = G.number_of_nodes()
+    N = G.number_of_nodes()
     ordering = list(reverse_cuthill_mckee_ordering(G))
     # make a copy with integer labels according to rcm ordering
     # this could be done without a copy if we really wanted to
-    H = nx.relabel_nodes(G, dict(zip(ordering, range(n))))
+    H = nx.relabel_nodes(G, dict(zip(ordering, range(N))))
     edges = (tuple(sorted((u, v))) for u, v in H.edges())
     betweenness = dict.fromkeys(edges, 0.0)
     if normalized:
-        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+        nb = (N - 1.0) * (N - 2.0)  # normalization factor
     else:
         nb = 2.0
     for row, (e) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
-        pos = dict(zip(row.argsort()[::-1], range(1, n + 1)))
-        for i in range(n):
-            betweenness[e] += (i + 1 - pos[i]) * row[i]
-            betweenness[e] += (n - i - pos[i]) * row[i]
+        pos = dict(zip(row.argsort()[::-1], range(1, N + 1)))
+        for i in range(N):
+            betweenness[e] += (i + 1 - pos[i]) * row.item(i)
+            betweenness[e] += (N - i - pos[i]) * row.item(i)
         betweenness[e] /= nb
-    return {(ordering[s], ordering[t]): v for (s, t), v in betweenness.items()}
+    return {(ordering[s], ordering[t]): b for (s, t), b in betweenness.items()}
diff --git a/networkx/algorithms/centrality/current_flow_betweenness_subset.py b/networkx/algorithms/centrality/current_flow_betweenness_subset.py
index 38e744a835a..c6790b218e9 100644
--- a/networkx/algorithms/centrality/current_flow_betweenness_subset.py
+++ b/networkx/algorithms/centrality/current_flow_betweenness_subset.py
@@ -96,27 +96,27 @@ def current_flow_betweenness_centrality_subset(
 
     if not nx.is_connected(G):
         raise nx.NetworkXError("Graph not connected.")
-    n = G.number_of_nodes()
+    N = G.number_of_nodes()
     ordering = list(reverse_cuthill_mckee_ordering(G))
     # make a copy with integer labels according to rcm ordering
     # this could be done without a copy if we really wanted to
-    mapping = dict(zip(ordering, range(n)))
+    mapping = dict(zip(ordering, range(N)))
     H = nx.relabel_nodes(G, mapping)
-    betweenness = dict.fromkeys(H, 0.0)  # b[v]=0 for v in H
+    betweenness = dict.fromkeys(H, 0.0)  # b[n]=0 for n in H
     for row, (s, t) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
         for ss in sources:
             i = mapping[ss]
             for tt in targets:
                 j = mapping[tt]
-                betweenness[s] += 0.5 * np.abs(row[i] - row[j])
-                betweenness[t] += 0.5 * np.abs(row[i] - row[j])
+                betweenness[s] += 0.5 * abs(row.item(i) - row.item(j))
+                betweenness[t] += 0.5 * abs(row.item(i) - row.item(j))
     if normalized:
-        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+        nb = (N - 1.0) * (N - 2.0)  # normalization factor
     else:
         nb = 2.0
-    for v in H:
-        betweenness[v] = betweenness[v] / nb + 1.0 / (2 - n)
-    return {ordering[k]: v for k, v in betweenness.items()}
+    for node in H:
+        betweenness[node] = betweenness[node] / nb + 1.0 / (2 - N)
+    return {ordering[node]: value for node, value in betweenness.items()}
 
 
 @not_implemented_for("directed")
@@ -204,16 +204,16 @@ def edge_current_flow_betweenness_centrality_subset(
 
     if not nx.is_connected(G):
         raise nx.NetworkXError("Graph not connected.")
-    n = G.number_of_nodes()
+    N = G.number_of_nodes()
     ordering = list(reverse_cuthill_mckee_ordering(G))
     # make a copy with integer labels according to rcm ordering
     # this could be done without a copy if we really wanted to
-    mapping = dict(zip(ordering, range(n)))
+    mapping = dict(zip(ordering, range(N)))
     H = nx.relabel_nodes(G, mapping)
     edges = (tuple(sorted((u, v))) for u, v in H.edges())
     betweenness = dict.fromkeys(edges, 0.0)
     if normalized:
-        nb = (n - 1.0) * (n - 2.0)  # normalization factor
+        nb = (N - 1.0) * (N - 2.0)  # normalization factor
     else:
         nb = 2.0
     for row, (e) in flow_matrix_row(H, weight=weight, dtype=dtype, solver=solver):
@@ -221,6 +221,6 @@ def edge_current_flow_betweenness_centrality_subset(
             i = mapping[ss]
             for tt in targets:
                 j = mapping[tt]
-                betweenness[e] += 0.5 * np.abs(row[i] - row[j])
+                betweenness[e] += 0.5 * abs(row.item(i) - row.item(j))
         betweenness[e] /= nb
-    return {(ordering[s], ordering[t]): v for (s, t), v in betweenness.items()}
+    return {(ordering[s], ordering[t]): value for (s, t), value in betweenness.items()}
diff --git a/networkx/algorithms/centrality/current_flow_closeness.py b/networkx/algorithms/centrality/current_flow_closeness.py
index c4c8dd56c3e..92c892f7449 100644
--- a/networkx/algorithms/centrality/current_flow_closeness.py
+++ b/networkx/algorithms/centrality/current_flow_closeness.py
@@ -74,24 +74,22 @@ def current_flow_closeness_centrality(G, weight=None, dtype=float, solver="lu"):
         "lu": SuperLUInverseLaplacian,
         "cg": CGInverseLaplacian,
     }
-    n = G.number_of_nodes()
+    N = G.number_of_nodes()
     ordering = list(reverse_cuthill_mckee_ordering(G))
     # make a copy with integer labels according to rcm ordering
     # this could be done without a copy if we really wanted to
-    H = nx.relabel_nodes(G, dict(zip(ordering, range(n))))
-    betweenness = dict.fromkeys(H, 0.0)  # b[v]=0 for v in H
-    n = H.number_of_nodes()
-    L = nx.laplacian_matrix(H, nodelist=range(n), weight=weight).asformat("csc")
+    H = nx.relabel_nodes(G, dict(zip(ordering, range(N))))
+    betweenness = dict.fromkeys(H, 0.0)  # b[n]=0 for n in H
+    N = H.number_of_nodes()
+    L = nx.laplacian_matrix(H, nodelist=range(N), weight=weight).asformat("csc")
     L = L.astype(dtype)
     C2 = solvername[solver](L, width=1, dtype=dtype)  # initialize solver
     for v in H:
         col = C2.get_row(v)
         for w in H:
-            betweenness[v] += col[v] - 2 * col[w]
-            betweenness[w] += col[v]
-    for v in H:
-        betweenness[v] = 1 / (betweenness[v])
-    return {ordering[k]: v for k, v in betweenness.items()}
+            betweenness[v] += col.item(v) - 2 * col.item(w)
+            betweenness[w] += col.item(v)
+    return {ordering[node]: 1 / value for node, value in betweenness.items()}
 
 
 information_centrality = current_flow_closeness_centrality
diff --git a/networkx/algorithms/centrality/eigenvector.py b/networkx/algorithms/centrality/eigenvector.py
index f7fcbf78060..ed57b2aeb32 100644
--- a/networkx/algorithms/centrality/eigenvector.py
+++ b/networkx/algorithms/centrality/eigenvector.py
@@ -338,4 +338,4 @@ def eigenvector_centrality_numpy(G, weight=None, max_iter=50, tol=0):
     )
     largest = eigenvector.flatten().real
     norm = np.sign(largest.sum()) * sp.linalg.norm(largest)
-    return dict(zip(G, largest / norm))
+    return dict(zip(G, (largest / norm).tolist()))
diff --git a/networkx/algorithms/centrality/katz.py b/networkx/algorithms/centrality/katz.py
index 527ec622fc4..d85ffd2dcd2 100644
--- a/networkx/algorithms/centrality/katz.py
+++ b/networkx/algorithms/centrality/katz.py
@@ -325,6 +325,6 @@ def katz_centrality_numpy(G, alpha=0.1, beta=1.0, normalized=True, weight=None):
     n = A.shape[0]
     centrality = np.linalg.solve(np.eye(n, n) - (alpha * A), b).squeeze()
 
-    # Normalize: rely on truediv to cast to float
+    # Normalize: rely on truediv to cast to float, then tolist to make Python numbers
     norm = np.sign(sum(centrality)) * np.linalg.norm(centrality) if normalized else 1
-    return dict(zip(nodelist, centrality / norm))
+    return dict(zip(nodelist, (centrality / norm).tolist()))
diff --git a/networkx/algorithms/centrality/laplacian.py b/networkx/algorithms/centrality/laplacian.py
index 92ad463884b..66207ed2189 100644
--- a/networkx/algorithms/centrality/laplacian.py
+++ b/networkx/algorithms/centrality/laplacian.py
@@ -144,6 +144,6 @@ def laplacian_centrality(
         if normalized:
             lapl_cent = lapl_cent / full_energy
 
-        laplace_centralities_dict[node] = lapl_cent
+        laplace_centralities_dict[node] = float(lapl_cent)
 
     return laplace_centralities_dict
diff --git a/networkx/algorithms/centrality/second_order.py b/networkx/algorithms/centrality/second_order.py
index b08fe66b71f..35583cd63e5 100644
--- a/networkx/algorithms/centrality/second_order.py
+++ b/networkx/algorithms/centrality/second_order.py
@@ -134,5 +134,8 @@ def _Qj(P, j):
         )  # eq 3
 
     return dict(
-        zip(G.nodes, [np.sqrt(2 * np.sum(M[:, i]) - n * (n + 1)) for i in range(n)])
+        zip(
+            G.nodes,
+            (float(np.sqrt(2 * np.sum(M[:, i]) - n * (n + 1))) for i in range(n)),
+        )
     )  # eq 6
diff --git a/networkx/algorithms/centrality/subgraph_alg.py b/networkx/algorithms/centrality/subgraph_alg.py
index 3234e854b3c..29a284c547c 100644
--- a/networkx/algorithms/centrality/subgraph_alg.py
+++ b/networkx/algorithms/centrality/subgraph_alg.py
@@ -278,7 +278,7 @@ def communicability_betweenness_centrality(G):
         B[i, :] = 0
         B[:, i] = 0
         B -= np.diag(np.diag(B))
-        cbc[v] = B.sum()
+        cbc[v] = float(B.sum())
         # put row and col back
         A[i, :] = row
         A[:, i] = col
@@ -286,8 +286,7 @@ def communicability_betweenness_centrality(G):
     order = len(cbc)
     if order > 2:
         scale = 1.0 / ((order - 1.0) ** 2 - (order - 1.0))
-        for v in cbc:
-            cbc[v] *= scale
+        cbc = {node: value * scale for node, value in cbc.items()}
     return cbc
 
 
diff --git a/networkx/algorithms/centrality/trophic.py b/networkx/algorithms/centrality/trophic.py
index d6dcca1526f..6d1ba960ba9 100644
--- a/networkx/algorithms/centrality/trophic.py
+++ b/networkx/algorithms/centrality/trophic.py
@@ -76,7 +76,7 @@ def trophic_levels(G, weight="weight"):
     # all other nodes have levels as calculated
     nonzero_node_ids = (node_id for node_id, degree in G.in_degree if degree != 0)
     for i, node_id in enumerate(nonzero_node_ids):
-        levels[node_id] = y[i]
+        levels[node_id] = y.item(i)
 
     return levels
 
@@ -159,4 +159,4 @@ def trophic_incoherence_parameter(G, weight="weight", cannibalism=False):
             # Avoid copy otherwise
             G_2 = G
         diffs = trophic_differences(G_2, weight=weight)
-    return np.std(list(diffs.values()))
+    return float(np.std(list(diffs.values())))
diff --git a/networkx/algorithms/cluster.py b/networkx/algorithms/cluster.py
index 36e33f0226c..6c91ad28135 100644
--- a/networkx/algorithms/cluster.py
+++ b/networkx/algorithms/cluster.py
@@ -143,10 +143,10 @@ def wt(u, v):
             # Only compute the edge weight once, before the inner inner
             # loop.
             wij = wt(i, j)
-            weighted_triangles += sum(
-                np.cbrt([(wij * wt(j, k) * wt(k, i)) for k in inbrs & jnbrs])
-            )
-        yield (i, len(inbrs), 2 * weighted_triangles)
+            weighted_triangles += np.cbrt(
+                [(wij * wt(j, k) * wt(k, i)) for k in inbrs & jnbrs]
+            ).sum()
+        yield (i, len(inbrs), 2 * float(weighted_triangles))
 
 
 @not_implemented_for("multigraph")
@@ -213,38 +213,38 @@ def wt(u, v):
         for j in ipreds:
             jpreds = set(G._pred[j]) - {j}
             jsuccs = set(G._succ[j]) - {j}
-            directed_triangles += sum(
-                np.cbrt([(wt(j, i) * wt(k, i) * wt(k, j)) for k in ipreds & jpreds])
-            )
-            directed_triangles += sum(
-                np.cbrt([(wt(j, i) * wt(k, i) * wt(j, k)) for k in ipreds & jsuccs])
-            )
-            directed_triangles += sum(
-                np.cbrt([(wt(j, i) * wt(i, k) * wt(k, j)) for k in isuccs & jpreds])
-            )
-            directed_triangles += sum(
-                np.cbrt([(wt(j, i) * wt(i, k) * wt(j, k)) for k in isuccs & jsuccs])
-            )
+            directed_triangles += np.cbrt(
+                [(wt(j, i) * wt(k, i) * wt(k, j)) for k in ipreds & jpreds]
+            ).sum()
+            directed_triangles += np.cbrt(
+                [(wt(j, i) * wt(k, i) * wt(j, k)) for k in ipreds & jsuccs]
+            ).sum()
+            directed_triangles += np.cbrt(
+                [(wt(j, i) * wt(i, k) * wt(k, j)) for k in isuccs & jpreds]
+            ).sum()
+            directed_triangles += np.cbrt(
+                [(wt(j, i) * wt(i, k) * wt(j, k)) for k in isuccs & jsuccs]
+            ).sum()
 
         for j in isuccs:
             jpreds = set(G._pred[j]) - {j}
             jsuccs = set(G._succ[j]) - {j}
-            directed_triangles += sum(
-                np.cbrt([(wt(i, j) * wt(k, i) * wt(k, j)) for k in ipreds & jpreds])
-            )
-            directed_triangles += sum(
-                np.cbrt([(wt(i, j) * wt(k, i) * wt(j, k)) for k in ipreds & jsuccs])
-            )
-            directed_triangles += sum(
-                np.cbrt([(wt(i, j) * wt(i, k) * wt(k, j)) for k in isuccs & jpreds])
-            )
-            directed_triangles += sum(
-                np.cbrt([(wt(i, j) * wt(i, k) * wt(j, k)) for k in isuccs & jsuccs])
-            )
+            directed_triangles += np.cbrt(
+                [(wt(i, j) * wt(k, i) * wt(k, j)) for k in ipreds & jpreds]
+            ).sum()
+            directed_triangles += np.cbrt(
+                [(wt(i, j) * wt(k, i) * wt(j, k)) for k in ipreds & jsuccs]
+            ).sum()
+            directed_triangles += np.cbrt(
+                [(wt(i, j) * wt(i, k) * wt(k, j)) for k in isuccs & jpreds]
+            ).sum()
+            directed_triangles += np.cbrt(
+                [(wt(i, j) * wt(i, k) * wt(j, k)) for k in isuccs & jsuccs]
+            ).sum()
 
         dtotal = len(ipreds) + len(isuccs)
         dbidirectional = len(ipreds & isuccs)
-        yield (i, dtotal, dbidirectional, directed_triangles)
+        yield (i, dtotal, dbidirectional, float(directed_triangles))
 
 
 @nx._dispatchable(edge_attrs="weight")
diff --git a/networkx/algorithms/distance_measures.py b/networkx/algorithms/distance_measures.py
index 310c3913f01..8215b470af3 100644
--- a/networkx/algorithms/distance_measures.py
+++ b/networkx/algorithms/distance_measures.py
@@ -735,14 +735,14 @@ def resistance_distance(G, nodeA=None, nodeB=None, weight=None, invert_weight=Tr
     if nodeA is not None and nodeB is not None:
         i = node_list.index(nodeA)
         j = node_list.index(nodeB)
-        return Linv[i, i] + Linv[j, j] - Linv[i, j] - Linv[j, i]
+        return Linv.item(i, i) + Linv.item(j, j) - Linv.item(i, j) - Linv.item(j, i)
 
     elif nodeA is not None:
         i = node_list.index(nodeA)
         d = {}
         for n in G:
             j = node_list.index(n)
-            d[n] = Linv[i, i] + Linv[j, j] - Linv[i, j] - Linv[j, i]
+            d[n] = Linv.item(i, i) + Linv.item(j, j) - Linv.item(i, j) - Linv.item(j, i)
         return d
 
     elif nodeB is not None:
@@ -750,7 +750,7 @@ def resistance_distance(G, nodeA=None, nodeB=None, weight=None, invert_weight=Tr
         d = {}
         for n in G:
             i = node_list.index(n)
-            d[n] = Linv[i, i] + Linv[j, j] - Linv[i, j] - Linv[j, i]
+            d[n] = Linv.item(i, i) + Linv.item(j, j) - Linv.item(i, j) - Linv.item(j, i)
         return d
 
     else:
@@ -760,7 +760,12 @@ def resistance_distance(G, nodeA=None, nodeB=None, weight=None, invert_weight=Tr
             d[n] = {}
             for n2 in G:
                 j = node_list.index(n2)
-                d[n][n2] = Linv[i, i] + Linv[j, j] - Linv[i, j] - Linv[j, i]
+                d[n][n2] = (
+                    Linv.item(i, i)
+                    + Linv.item(j, j)
+                    - Linv.item(i, j)
+                    - Linv.item(j, i)
+                )
         return d
 
 
@@ -832,7 +837,7 @@ def effective_graph_resistance(G, weight=None, invert_weight=True):
 
     # Disconnected graphs have infinite Effective graph resistance
     if not nx.is_connected(G):
-        return np.inf
+        return float("inf")
 
     # Invert weights
     G = G.copy()
@@ -849,7 +854,7 @@ def effective_graph_resistance(G, weight=None, invert_weight=True):
 
     # Compute Effective graph resistance based on spectrum of the Laplacian
     # Self-loops are ignored
-    return np.sum(1 / mu[1:]) * G.number_of_nodes()
+    return float(np.sum(1 / mu[1:]) * G.number_of_nodes())
 
 
 @nx.utils.not_implemented_for("directed")
@@ -941,4 +946,4 @@ def kemeny_constant(G, *, weight=None):
     eig = np.sort(sp.linalg.eigvalsh(H.todense()))
 
     # Compute the Kemeny constant
-    return np.sum(1 / (1 - eig[:-1]))
+    return float(np.sum(1 / (1 - eig[:-1])))
diff --git a/networkx/algorithms/non_randomness.py b/networkx/algorithms/non_randomness.py
index d0e9acbf666..85483d330fa 100644
--- a/networkx/algorithms/non_randomness.py
+++ b/networkx/algorithms/non_randomness.py
@@ -84,7 +84,7 @@ def non_randomness(G, k=None, weight="weight"):
 
     # eq. 4.4
     eigenvalues = np.linalg.eigvals(nx.to_numpy_array(G, weight=weight))
-    nr = np.real(np.sum(eigenvalues[:k]))
+    nr = float(np.real(np.sum(eigenvalues[:k])))
 
     n = G.number_of_nodes()
     m = G.number_of_edges()
diff --git a/networkx/algorithms/shortest_paths/generic.py b/networkx/algorithms/shortest_paths/generic.py
index aa5fc5c89c1..81b72419ace 100644
--- a/networkx/algorithms/shortest_paths/generic.py
+++ b/networkx/algorithms/shortest_paths/generic.py
@@ -444,7 +444,7 @@ def path_length(v):
             all_pairs = nx.floyd_warshall(G, weight=weight)
             s = sum(sum(t.values()) for t in all_pairs.values())
         elif method == "floyd-warshall-numpy":
-            s = nx.floyd_warshall_numpy(G, weight=weight).sum()
+            s = float(nx.floyd_warshall_numpy(G, weight=weight).sum())
     return s / (n * (n - 1))
 
 
diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index 68625d009ea..765849984ea 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -1209,7 +1209,7 @@ def prune(cost):
         # assert sorted(G2.edges) == sorted(h for g, h in edge_path if h is not None)
         # print(vertex_path, edge_path, cost, file = sys.stderr)
         # assert cost == maxcost_value
-        yield list(vertex_path), list(edge_path), cost
+        yield list(vertex_path), list(edge_path), float(cost)
 
 
 @nx._dispatchable
@@ -1350,10 +1350,10 @@ def simrank(G, u, v):
 
     if isinstance(x, np.ndarray):
         if x.ndim == 1:
-            return dict(zip(G, x))
+            return dict(zip(G, x.tolist()))
         # else x.ndim == 2
-        return {u: dict(zip(G, row)) for u, row in zip(G, x)}
-    return x
+        return {u: dict(zip(G, row)) for u, row in zip(G, x.tolist())}
+    return float(x)
 
 
 def _simrank_similarity_python(
@@ -1653,8 +1653,9 @@ def panther_similarity(
     top_k_sorted = top_k_unsorted[np.argsort(S[top_k_unsorted])][::-1]
 
     # Add back the similarity scores
-    top_k_sorted_names = (node_map[n] for n in top_k_sorted)
-    top_k_with_val = dict(zip(top_k_sorted_names, S[top_k_sorted]))
+    top_k_with_val = dict(
+        zip(node_map[top_k_sorted].tolist(), S[top_k_sorted].tolist())
+    )
 
     # Remove the self-similarity
     top_k_with_val.pop(source, None)
@@ -1723,7 +1724,7 @@ def generate_random_paths(
     inv_row_sums = np.reciprocal(adj_mat.sum(axis=1)).reshape(-1, 1)
     transition_probabilities = adj_mat * inv_row_sums
 
-    node_map = np.array(G)
+    node_map = list(G)
     num_nodes = G.number_of_nodes()
 
     for path_index in range(sample_size):
diff --git a/networkx/algorithms/smallworld.py b/networkx/algorithms/smallworld.py
index 8ddf74887f2..05ae1708202 100644
--- a/networkx/algorithms/smallworld.py
+++ b/networkx/algorithms/smallworld.py
@@ -308,7 +308,7 @@ def sigma(G, niter=100, nrand=10, seed=None):
 
     sigma = (C / Cr) / (L / Lr)
 
-    return sigma
+    return float(sigma)
 
 
 @not_implemented_for("directed")
@@ -400,4 +400,4 @@ def omega(G, niter=5, nrand=10, seed=None):
 
     omega = (Lr / L) - (C / Cl)
 
-    return omega
+    return float(omega)
diff --git a/networkx/algorithms/walks.py b/networkx/algorithms/walks.py
index 91214c8e778..fe341757750 100644
--- a/networkx/algorithms/walks.py
+++ b/networkx/algorithms/walks.py
@@ -74,7 +74,7 @@ def number_of_walks(G, walk_length):
     # power = sp.sparse.linalg.matrix_power(A, walk_length)
     power = np.linalg.matrix_power(A.toarray(), walk_length)
     result = {
-        u: {v: power[u_idx, v_idx] for v_idx, v in enumerate(G)}
+        u: {v: power.item(u_idx, v_idx) for v_idx, v in enumerate(G)}
         for u_idx, u in enumerate(G)
     }
     return result
diff --git a/networkx/conftest.py b/networkx/conftest.py
index 20894e2aded..a6b63ef350e 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -156,13 +156,6 @@ def set_warnings():
 @pytest.fixture(autouse=True)
 def add_nx(doctest_namespace):
     doctest_namespace["nx"] = networkx
-    # TODO: remove the try-except block when we require numpy >= 2
-    try:
-        import numpy as np
-
-        np.set_printoptions(legacy="1.21")
-    except ImportError:
-        pass
 
 
 # What dependencies are installed?
diff --git a/networkx/convert_matrix.py b/networkx/convert_matrix.py
index f669a09ca5d..2fc1e784f5b 100644
--- a/networkx/convert_matrix.py
+++ b/networkx/convert_matrix.py
@@ -623,10 +623,11 @@ def _csr_gen_triples(A):
 
     """
     nrows = A.shape[0]
-    data, indices, indptr = A.data, A.indices, A.indptr
-    for i in range(nrows):
-        for j in range(indptr[i], indptr[i + 1]):
-            yield i, int(indices[j]), data[j]
+    indptr, dst_indices, data = A.indptr, A.indices, A.data
+    import numpy as np
+
+    src_indices = np.repeat(np.arange(nrows), np.diff(indptr))
+    return zip(src_indices.tolist(), dst_indices.tolist(), A.data.tolist())
 
 
 def _csc_gen_triples(A):
@@ -635,10 +636,11 @@ def _csc_gen_triples(A):
 
     """
     ncols = A.shape[1]
-    data, indices, indptr = A.data, A.indices, A.indptr
-    for i in range(ncols):
-        for j in range(indptr[i], indptr[i + 1]):
-            yield int(indices[j]), i, data[j]
+    indptr, src_indices, data = A.indptr, A.indices, A.data
+    import numpy as np
+
+    dst_indices = np.repeat(np.arange(ncols), np.diff(indptr))
+    return zip(src_indices.tolist(), dst_indices.tolist(), A.data.tolist())
 
 
 def _coo_gen_triples(A):
@@ -646,7 +648,7 @@ def _coo_gen_triples(A):
     of weighted edge triples.
 
     """
-    return ((int(i), int(j), d) for i, j, d in zip(A.row, A.col, A.data))
+    return zip(A.row.tolist(), A.col.tolist(), A.data.tolist())
 
 
 def _dok_gen_triples(A):
@@ -655,7 +657,8 @@ def _dok_gen_triples(A):
 
     """
     for (r, c), v in A.items():
-        yield r, c, v
+        # Use `v.item()` to convert a NumPy scalar to the appropriate Python scalar
+        yield int(r), int(c), v.item()
 
 
 def _generate_weighted_edges(A):
diff --git a/networkx/generators/classic.py b/networkx/generators/classic.py
index 54088be7519..4278a338d91 100644
--- a/networkx/generators/classic.py
+++ b/networkx/generators/classic.py
@@ -803,7 +803,7 @@ def star_graph(n, create_using=None):
     """
     n, nodes = n
     if isinstance(n, numbers.Integral):
-        nodes.append(n)  # there should be n+1 nodes
+        nodes.append(int(n))  # there should be n+1 nodes
     G = empty_graph(nodes, create_using)
     if G.is_directed():
         raise NetworkXError("Directed Graph not supported")
diff --git a/networkx/generators/expanders.py b/networkx/generators/expanders.py
index 85716e0e7a0..d1bddea3c95 100644
--- a/networkx/generators/expanders.py
+++ b/networkx/generators/expanders.py
@@ -308,7 +308,8 @@ def maybe_regular_expander(n, d, *, create_using=None, max_tries=100, seed=None)
             iterations -= 1
             # Faster than random.permutation(n) since there are only
             # (n-1)! distinct cycles against n! permutations of size n
-            cycle = np.concatenate((seed.permutation(n - 1), [n - 1]))
+            cycle = seed.permutation(n - 1).tolist()
+            cycle.append(n - 1)
 
             new_edges = {
                 (u, v)
diff --git a/networkx/linalg/algebraicconnectivity.py b/networkx/linalg/algebraicconnectivity.py
index 70f23bbac97..870b4ec5f59 100644
--- a/networkx/linalg/algebraicconnectivity.py
+++ b/networkx/linalg/algebraicconnectivity.py
@@ -222,7 +222,7 @@ def project(X):
         # element needs to modified. Changing to infinity forces a zero in the
         # corresponding element in the solution.
         i = (A.indptr[1:] - A.indptr[:-1]).argmax()
-        A[i, i] = float("inf")
+        A[i, i] = np.inf
         solver = _LUSolver(A)
     else:
         raise nx.NetworkXError(f"Unknown linear system solver: {method}")
@@ -398,12 +398,12 @@ def algebraic_connectivity(
 
     L = nx.laplacian_matrix(G)
     if L.shape[0] == 2:
-        return 2.0 * L[0, 0] if not normalized else 2.0
+        return 2.0 * float(L[0, 0]) if not normalized else 2.0
 
     find_fiedler = _get_fiedler_func(method)
     x = None if method != "lobpcg" else _rcm_estimate(G, G)
     sigma, fiedler = find_fiedler(L, x, normalized, tol, seed)
-    return sigma
+    return float(sigma)
 
 
 @not_implemented_for("directed")
@@ -653,4 +653,4 @@ def spectral_bisection(
     nodes = np.array(list(G))
     pos_vals = v >= 0
 
-    return set(nodes[~pos_vals]), set(nodes[pos_vals])
+    return set(nodes[~pos_vals].tolist()), set(nodes[pos_vals].tolist())
diff --git a/networkx/linalg/laplacianmatrix.py b/networkx/linalg/laplacianmatrix.py
index 13aebff4998..bf2775a4f01 100644
--- a/networkx/linalg/laplacianmatrix.py
+++ b/networkx/linalg/laplacianmatrix.py
@@ -249,7 +249,7 @@ def total_spanning_tree_weight(G, weight=None):
 
     G_laplacian = nx.laplacian_matrix(G, weight=weight).toarray()
     # Determinant ignoring first row and column
-    return abs(np.linalg.det(G_laplacian[1:, 1:]))
+    return float(abs(np.linalg.det(G_laplacian[1:, 1:])))
 
 
 ###############################################################################
diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 8a0e127caa8..1533dc55435 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -864,13 +864,15 @@ def _convert_and_call_for_tests(
                 msg += " with the given arguments"
             pytest.xfail(msg)
 
-        from collections.abc import Iterator
+        from collections.abc import Iterable, Iterator, Mapping
         from copy import copy
         from io import BufferedReader, BytesIO
         from itertools import tee
         from random import Random
 
+        import numpy as np
         from numpy.random import Generator, RandomState
+        from scipy.sparse import sparray
 
         # We sometimes compare the backend result to the original result,
         # so we need two sets of arguments. We tee iterators and copy
@@ -951,6 +953,50 @@ def _convert_and_call_for_tests(
         ):
             raise RuntimeError(f"`returns_graph` is incorrect for {self.name}")
 
+        def check_result(val, depth=0):
+            if isinstance(val, np.number):
+                raise RuntimeError(
+                    f"{self.name} returned a numpy scalar {val} ({type(val)}, depth={depth})"
+                )
+            if isinstance(val, np.ndarray | sparray):
+                return
+            if isinstance(val, nx.Graph):
+                check_result(val._node, depth=depth + 1)
+                check_result(val._adj, depth=depth + 1)
+                return
+            if isinstance(val, Iterator):
+                raise NotImplementedError
+            if isinstance(val, Iterable) and not isinstance(val, str):
+                for x in val:
+                    check_result(x, depth=depth + 1)
+            if isinstance(val, Mapping):
+                for x in val.values():
+                    check_result(x, depth=depth + 1)
+
+        def check_iterator(it):
+            for val in it:
+                try:
+                    check_result(val)
+                except RuntimeError as exc:
+                    raise RuntimeError(
+                        f"{self.name} returned a numpy scalar {val} ({type(val)})"
+                    ) from exc
+                yield val
+
+        if self.name in {"from_edgelist"}:
+            # numpy scalars are explicitly given as values in some tests
+            pass
+        elif isinstance(result, Iterator):
+            result = check_iterator(result)
+        else:
+            try:
+                check_result(result)
+            except RuntimeError as exc:
+                raise RuntimeError(
+                    f"{self.name} returned a numpy scalar {result} ({type(result)})"
+                ) from exc
+            check_result(result)
+
         if self.name in {
             "edmonds_karp_core",
             "barycenter",

From 046eed45eeefec5c71d07f38fdeec4bd70a5b973 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 1 Mar 2024 18:47:39 -0800
Subject: [PATCH 091/129] Bump changelist from 0.4 to 0.5 (#7325)

Bumps [changelist](https://github.com/scientific-python/changelist) from 0.4 to 0.5.
- [Release notes](https://github.com/scientific-python/changelist/releases)
- [Changelog](https://github.com/scientific-python/changelist/blob/main/CHANGELOG.md)
- [Commits](https://github.com/scientific-python/changelist/compare/v0.4...v0.5)

---
updated-dependencies:
- dependency-name: changelist
  dependency-type: direct:development
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 pyproject.toml             | 2 +-
 requirements/developer.txt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 47be7f9a6d3..ba1d1db7345 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -61,7 +61,7 @@ default = [
     'pandas>=1.4',
 ]
 developer = [
-    'changelist==0.4',
+    'changelist==0.5',
     'pre-commit>=3.2',
     'mypy>=1.1',
     'rtoml',
diff --git a/requirements/developer.txt b/requirements/developer.txt
index bc1312bf30e..b74a1f33b5c 100644
--- a/requirements/developer.txt
+++ b/requirements/developer.txt
@@ -1,6 +1,6 @@
 # Generated via tools/generate_requirements.py and pre-commit hook.
 # Do not edit this file; modify pyproject.toml instead.
-changelist==0.4
+changelist==0.5
 pre-commit>=3.2
 mypy>=1.1
 rtoml

From 00e3c4c4ecad08bff17b894f6d39bcc96a3c583f Mon Sep 17 00:00:00 2001
From: peijenburg <mas8berg@gmail.com>
Date: Sun, 3 Mar 2024 05:45:14 +0100
Subject: [PATCH 092/129] Add number_of_spanning_trees (#7100)

Adds number_of_spanning_trees and deprecates
total_spanning_tree_weight in favor of the new function.

---------

Co-authored-by: Dan Schult <dschult@colgate.edu>
Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 doc/developer/deprecations.rst             |   1 +
 doc/reference/algorithms/tree.rst          |   1 +
 networkx/algorithms/tree/mst.py            | 135 ++++++++++++++++++
 networkx/algorithms/tree/tests/test_mst.py | 123 ++++++++++++++++
 networkx/conftest.py                       |   4 +
 networkx/linalg/laplacianmatrix.py         | 155 ++++++++++++++++-----
 6 files changed, 388 insertions(+), 31 deletions(-)

diff --git a/doc/developer/deprecations.rst b/doc/developer/deprecations.rst
index 099d47cd419..a54295865ca 100644
--- a/doc/developer/deprecations.rst
+++ b/doc/developer/deprecations.rst
@@ -70,5 +70,6 @@ Version 3.5
   to return a dict. See #6527
 * Change ``shortest_path`` in ``algorithms/shortest_path/generic.py``
   to return a iterator. See #6527
+* Remove ``total_spanning_tree_weight`` from ``linalg/laplacianmatrix.py``
 * Remove ``create`` keyword argument from ``nonisomorphic_trees`` in 
   ``generators/nonisomorphic_trees``.
diff --git a/doc/reference/algorithms/tree.rst b/doc/reference/algorithms/tree.rst
index 4c7c3e6f585..363d1e9665b 100644
--- a/doc/reference/algorithms/tree.rst
+++ b/doc/reference/algorithms/tree.rst
@@ -64,6 +64,7 @@ Spanning Trees
    minimum_spanning_edges
    maximum_spanning_edges
    SpanningTreeIterator
+   number_of_spanning_trees
 
 Decomposition
 -------------
diff --git a/networkx/algorithms/tree/mst.py b/networkx/algorithms/tree/mst.py
index 850536edf6c..72c1980cb15 100644
--- a/networkx/algorithms/tree/mst.py
+++ b/networkx/algorithms/tree/mst.py
@@ -18,6 +18,7 @@
     "maximum_spanning_edges",
     "minimum_spanning_tree",
     "maximum_spanning_tree",
+    "number_of_spanning_trees",
     "random_spanning_tree",
     "partition_spanning_tree",
     "EdgePartition",
@@ -1136,3 +1137,137 @@ def _clear_partition(self, G):
         for u, v, d in G.edges(data=True):
             if self.partition_key in d:
                 del d[self.partition_key]
+
+
+@nx._dispatchable(edge_attrs="weight")
+def number_of_spanning_trees(G, *, root=None, weight=None):
+    """Returns the number of spanning trees in `G`.
+
+    A spanning tree for an undirected graph is a tree that connects
+    all nodes in the graph. For a directed graph, the analog of a
+    spanning tree is called a (spanning) arborescence. The arborescence
+    includes a unique directed path from the `root` node to each other node.
+    The graph must be weakly connected, and the root must be a node
+    that includes all nodes as successors [3]_. Note that to avoid
+    discussing sink-roots and reverse-arborescences, we have reversed
+    the edge orientation from [3]_ and use the in-degree laplacian.
+
+    This function (when `weight` is `None`) returns the number of
+    spanning trees for an undirected graph and the number of
+    arborescences from a single root node for a directed graph.
+    When `weight` is the name of an edge attribute which holds the
+    weight value of each edge, the function returns the sum over
+    all trees of the multiplicative weight of each tree. That is,
+    the weight of the tree is the product of its edge weights.
+
+    Kirchoff's Tree Matrix Theorem states that any cofactor of the
+    Laplacian matrix of a graph is the number of spanning trees in the
+    graph. (Here we use cofactors for a diagonal entry so that the
+    cofactor becomes the determinant of the matrix with one row
+    and its matching column removed.) For a weighted Laplacian matrix,
+    the cofactor is the sum across all spanning trees of the
+    multiplicative weight of each tree. That is, the weight of each
+    tree is the product of its edge weights. The theorem is also
+    known as Kirchhoff's theorem [1]_ and the Matrix-Tree theorem [2]_.
+
+    For directed graphs, a similar theorem (Tutte's Theorem) holds with
+    the cofactor chosen to be the one with row and column removed that
+    correspond to the root. The cofactor is the number of arborescences
+    with the specified node as root. And the weighted version gives the
+    sum of the arborescence weights with root `root`. The arborescence
+    weight is the product of its edge weights.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+
+    root : node
+       A node in the directed graph `G` that has all nodes as descendants.
+       (This is ignored for undirected graphs.)
+
+    weight : string or None, optional (default=None)
+        The name of the edge attribute holding the edge weight.
+        If `None`, then each edge is assumed to have a weight of 1.
+
+    Returns
+    -------
+    Number
+        Undirected graphs:
+            The number of spanning trees of the graph `G`.
+            Or the sum of all spanning tree weights of the graph `G`
+            where the weight of a tree is the product of its edge weights.
+        Directed graphs:
+            The number of arborescences of `G` rooted at node `root`.
+            Or the sum of all arborescence weights of the graph `G` with
+            specified root where the weight of an arborescence is the product
+            of its edge weights.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If `G` does not contain any nodes.
+
+    NetworkXError
+        If the graph `G` is directed and the root node
+        is not specified or is not in G.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> round(nx.number_of_spanning_trees(G))
+    125
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=2)
+    >>> G.add_edge(1, 3, weight=1)
+    >>> G.add_edge(2, 3, weight=1)
+    >>> round(nx.number_of_spanning_trees(G, weight="weight"))
+    5
+
+    Notes
+    -----
+    Self-loops are excluded. Multi-edges are contracted in one edge
+    equal to the sum of the weights.
+
+    References
+    ----------
+    .. [1] Wikipedia
+       "Kirchhoff's theorem."
+       https://en.wikipedia.org/wiki/Kirchhoff%27s_theorem
+    .. [2] Kirchhoff, G. R.
+        Über die Auflösung der Gleichungen, auf welche man
+        bei der Untersuchung der linearen Vertheilung
+        Galvanischer Ströme geführt wird
+        Annalen der Physik und Chemie, vol. 72, pp. 497-508, 1847.
+    .. [3] Margoliash, J.
+        "Matrix-Tree Theorem for Directed Graphs"
+        https://www.math.uchicago.edu/~may/VIGRE/VIGRE2010/REUPapers/Margoliash.pdf
+    """
+    import numpy as np
+
+    if len(G) == 0:
+        raise nx.NetworkXPointlessConcept("Graph G must contain at least one node.")
+
+    # undirected G
+    if not nx.is_directed(G):
+        if not nx.is_connected(G):
+            return 0
+        G_laplacian = nx.laplacian_matrix(G, weight=weight).toarray()
+        return float(np.linalg.det(G_laplacian[1:, 1:]))
+
+    # directed G
+    if root is None:
+        raise nx.NetworkXError("Input `root` must be provided when G is directed")
+    if root not in G:
+        raise nx.NetworkXError("The node root is not in the graph G.")
+    if not nx.is_weakly_connected(G):
+        return 0
+
+    # Compute directed Laplacian matrix
+    nodelist = [root] + [n for n in G if n != root]
+    A = nx.adjacency_matrix(G, nodelist=nodelist, weight=weight)
+    D = np.diag(A.sum(axis=0))
+    G_laplacian = D - A
+
+    # Compute number of spanning trees
+    return float(np.linalg.det(G_laplacian[1:, 1:]))
diff --git a/networkx/algorithms/tree/tests/test_mst.py b/networkx/algorithms/tree/tests/test_mst.py
index bc55000a6e6..a6048d5472a 100644
--- a/networkx/algorithms/tree/tests/test_mst.py
+++ b/networkx/algorithms/tree/tests/test_mst.py
@@ -730,3 +730,126 @@ def test_random_spanning_tree_single_node_loop():
     rst = nx.tree.random_spanning_tree(G)
     assert len(rst.nodes) == 1
     assert len(rst.edges) == 0
+
+
+class TestNumberSpanningTrees:
+    @classmethod
+    def setup_class(cls):
+        global np
+        np = pytest.importorskip("numpy")
+
+    def test_nst_disconnected(self):
+        G = nx.empty_graph(2)
+        assert np.isclose(nx.number_of_spanning_trees(G), 0)
+
+    def test_nst_no_nodes(self):
+        G = nx.Graph()
+        with pytest.raises(nx.NetworkXPointlessConcept):
+            nx.number_of_spanning_trees(G)
+
+    def test_nst_weight(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=1)
+        G.add_edge(1, 3, weight=1)
+        G.add_edge(2, 3, weight=2)
+        # weights are ignored
+        assert np.isclose(nx.number_of_spanning_trees(G), 3)
+        # including weight
+        assert np.isclose(nx.number_of_spanning_trees(G, weight="weight"), 5)
+
+    def test_nst_negative_weight(self):
+        G = nx.Graph()
+        G.add_edge(1, 2, weight=1)
+        G.add_edge(1, 3, weight=-1)
+        G.add_edge(2, 3, weight=-2)
+        # weights are ignored
+        assert np.isclose(nx.number_of_spanning_trees(G), 3)
+        # including weight
+        assert np.isclose(nx.number_of_spanning_trees(G, weight="weight"), -1)
+
+    def test_nst_selfloop(self):
+        # self-loops are ignored
+        G = nx.complete_graph(3)
+        G.add_edge(1, 1)
+        assert np.isclose(nx.number_of_spanning_trees(G), 3)
+
+    def test_nst_multigraph(self):
+        G = nx.MultiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(1, 2)
+        G.add_edge(1, 3)
+        G.add_edge(2, 3)
+        assert np.isclose(nx.number_of_spanning_trees(G), 5)
+
+    def test_nst_complete_graph(self):
+        # this is known as Cayley's formula
+        N = 5
+        G = nx.complete_graph(N)
+        assert np.isclose(nx.number_of_spanning_trees(G), N ** (N - 2))
+
+    def test_nst_path_graph(self):
+        G = nx.path_graph(5)
+        assert np.isclose(nx.number_of_spanning_trees(G), 1)
+
+    def test_nst_cycle_graph(self):
+        G = nx.cycle_graph(5)
+        assert np.isclose(nx.number_of_spanning_trees(G), 5)
+
+    def test_nst_directed_noroot(self):
+        G = nx.empty_graph(3, create_using=nx.MultiDiGraph)
+        with pytest.raises(nx.NetworkXError):
+            nx.number_of_spanning_trees(G)
+
+    def test_nst_directed_root_not_exist(self):
+        G = nx.empty_graph(3, create_using=nx.MultiDiGraph)
+        with pytest.raises(nx.NetworkXError):
+            nx.number_of_spanning_trees(G, root=42)
+
+    def test_nst_directed_not_weak_connected(self):
+        G = nx.DiGraph()
+        G.add_edge(1, 2)
+        G.add_edge(3, 4)
+        assert np.isclose(nx.number_of_spanning_trees(G, root=1), 0)
+
+    def test_nst_directed_cycle_graph(self):
+        G = nx.DiGraph()
+        G = nx.cycle_graph(7, G)
+        assert np.isclose(nx.number_of_spanning_trees(G, root=0), 1)
+
+    def test_nst_directed_complete_graph(self):
+        G = nx.DiGraph()
+        G = nx.complete_graph(7, G)
+        assert np.isclose(nx.number_of_spanning_trees(G, root=0), 7**5)
+
+    def test_nst_directed_multi(self):
+        G = nx.MultiDiGraph()
+        G = nx.cycle_graph(3, G)
+        G.add_edge(1, 2)
+        assert np.isclose(nx.number_of_spanning_trees(G, root=0), 2)
+
+    def test_nst_directed_selfloop(self):
+        G = nx.MultiDiGraph()
+        G = nx.cycle_graph(3, G)
+        G.add_edge(1, 1)
+        assert np.isclose(nx.number_of_spanning_trees(G, root=0), 1)
+
+    def test_nst_directed_weak_connected(self):
+        G = nx.MultiDiGraph()
+        G = nx.cycle_graph(3, G)
+        G.remove_edge(1, 2)
+        assert np.isclose(nx.number_of_spanning_trees(G, root=0), 0)
+
+    def test_nst_directed_weighted(self):
+        # from root=1:
+        # arborescence 1: 1->2, 1->3, weight=2*1
+        # arborescence 2: 1->2, 2->3, weight=2*3
+        G = nx.DiGraph()
+        G.add_edge(1, 2, weight=2)
+        G.add_edge(1, 3, weight=1)
+        G.add_edge(2, 3, weight=3)
+        Nst = nx.number_of_spanning_trees(G, root=1, weight="weight")
+        assert np.isclose(Nst, 8)
+        Nst = nx.number_of_spanning_trees(G, root=2, weight="weight")
+        assert np.isclose(Nst, 0)
+        Nst = nx.number_of_spanning_trees(G, root=3, weight="weight")
+        assert np.isclose(Nst, 0)
diff --git a/networkx/conftest.py b/networkx/conftest.py
index a6b63ef350e..2f5f6cfdaf7 100644
--- a/networkx/conftest.py
+++ b/networkx/conftest.py
@@ -148,6 +148,9 @@ def set_warnings():
     warnings.filterwarnings(
         "ignore", category=DeprecationWarning, message="\n\nk_corona"
     )
+    warnings.filterwarnings(
+        "ignore", category=DeprecationWarning, message="\n\ntotal_spanning_tree_weight"
+    )
     warnings.filterwarnings(
         "ignore", category=DeprecationWarning, message=r"\n\nThe 'create=matrix'"
     )
@@ -220,6 +223,7 @@ def add_nx(doctest_namespace):
     "algorithms/node_classification.py",
     "algorithms/non_randomness.py",
     "algorithms/shortest_paths/dense.py",
+    "algorithms/tree/mst.py",
     "generators/expanders.py",
     "linalg/bethehessianmatrix.py",
     "linalg/laplacianmatrix.py",
diff --git a/networkx/linalg/laplacianmatrix.py b/networkx/linalg/laplacianmatrix.py
index bf2775a4f01..1df4b422b76 100644
--- a/networkx/linalg/laplacianmatrix.py
+++ b/networkx/linalg/laplacianmatrix.py
@@ -1,7 +1,7 @@
 """Laplacian matrix of graphs.
 
-All calculations here are done using the out-degree. For Laplacians 
-using in-degree, us `G.reverse(copy=False)` instead of `G`.
+All calculations here are done using the out-degree. For Laplacians using
+in-degree, use `G.reverse(copy=False)` instead of `G` and take the transpose.
 
 The `laplacian_matrix` function provides an unnormalized matrix, 
 while `normalized_laplacian_matrix`, `directed_laplacian_matrix`, 
@@ -53,7 +53,8 @@ def laplacian_matrix(G, nodelist=None, weight="weight"):
     or `directed_combinatorial_laplacian_matrix`.
 
     This calculation uses the out-degree of the graph `G`. To use the
-    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+    in-degree for calculations instead, use `G.reverse(copy=False)` and
+    take the transpose.
 
     See Also
     --------
@@ -90,11 +91,26 @@ def laplacian_matrix(G, nodelist=None, weight="weight"):
      [-1  2 -1  0]
      [ 0  0  1 -1]
      [ 0  0 -1  1]]
-    >>> G = nx.Graph(DiG)
-    >>> print(nx.laplacian_matrix(G).toarray())
+
+    Notice that node 4 is represented by the third column and row. This is because
+    by default the row/column order is the order of `G.nodes` (i.e. the node added
+    order -- in the edgelist, 4 first appears in (2, 4), before node 3 in edge (4, 3).)
+    To control the node order of the matrix, use the `nodelist` argument.
+
+    >>> print(nx.laplacian_matrix(DiG, nodelist=[1, 2, 3, 4]).toarray())
     [[ 1 -1  0  0]
-     [-1  2 -1  0]
-     [ 0 -1  2 -1]
+     [-1  2  0 -1]
+     [ 0  0  1 -1]
+     [ 0  0 -1  1]]
+
+    This calculation uses the out-degree of the graph `G`. To use the
+    in-degree for calculations instead, use `G.reverse(copy=False)` and
+    take the transpose.
+
+    >>> print(nx.laplacian_matrix(DiG.reverse(copy=False)).toarray().T)
+    [[ 1 -1  0  0]
+     [-1  1 -1  0]
+     [ 0  0  2 -1]
      [ 0  0 -1  1]]
 
     References
@@ -154,7 +170,8 @@ def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     the adjacency matrix [2]_.
 
     This calculation uses the out-degree of the graph `G`. To use the
-    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+    in-degree for calculations instead, use `G.reverse(copy=False)` and
+    take the transpose.
 
     For an unnormalized output, use `laplacian_matrix`.
 
@@ -176,7 +193,18 @@ def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
      [-0.7071  1.     -0.7071  0.    ]
      [ 0.      0.      1.     -1.    ]
      [ 0.      0.     -1.      1.    ]]
-    >>> G = nx.Graph(DiG)
+
+    Notice that node 4 is represented by the third column and row. This is because
+    by default the row/column order is the order of `G.nodes` (i.e. the node added
+    order -- in the edgelist, 4 first appears in (2, 4), before node 3 in edge (4, 3).)
+    To control the node order of the matrix, use the `nodelist` argument.
+
+    >>> print(nx.normalized_laplacian_matrix(DiG, nodelist=[1, 2, 3, 4]).toarray())
+    [[ 1.     -0.7071  0.      0.    ]
+     [-0.7071  1.      0.     -0.7071]
+     [ 0.      0.      1.     -1.    ]
+     [ 0.      0.     -1.      1.    ]]
+    >>> G = nx.Graph(edges)
     >>> print(nx.normalized_laplacian_matrix(G).toarray())
     [[ 1.     -0.7071  0.      0.    ]
      [-0.7071  1.     -0.5     0.    ]
@@ -206,50 +234,113 @@ def normalized_laplacian_matrix(G, nodelist=None, weight="weight"):
     if nodelist is None:
         nodelist = list(G)
     A = nx.to_scipy_sparse_array(G, nodelist=nodelist, weight=weight, format="csr")
-    n, m = A.shape
+    n, _ = A.shape
     diags = A.sum(axis=1)
     # TODO: rm csr_array wrapper when spdiags can produce arrays
-    D = sp.sparse.csr_array(sp.sparse.spdiags(diags, 0, m, n, format="csr"))
+    D = sp.sparse.csr_array(sp.sparse.spdiags(diags, 0, n, n, format="csr"))
     L = D - A
     with np.errstate(divide="ignore"):
         diags_sqrt = 1.0 / np.sqrt(diags)
     diags_sqrt[np.isinf(diags_sqrt)] = 0
     # TODO: rm csr_array wrapper when spdiags can produce arrays
-    DH = sp.sparse.csr_array(sp.sparse.spdiags(diags_sqrt, 0, m, n, format="csr"))
+    DH = sp.sparse.csr_array(sp.sparse.spdiags(diags_sqrt, 0, n, n, format="csr"))
     return DH @ (L @ DH)
 
 
 @nx._dispatchable(edge_attrs="weight")
-def total_spanning_tree_weight(G, weight=None):
+def total_spanning_tree_weight(G, weight=None, root=None):
     """
     Returns the total weight of all spanning trees of `G`.
 
-    Kirchoff's Tree Matrix Theorem states that the determinant of any cofactor of the
-    Laplacian matrix of a graph is the number of spanning trees in the graph. For a
-    weighted Laplacian matrix, it is the sum across all spanning trees of the
-    multiplicative weight of each tree. That is, the weight of each tree is the
-    product of its edge weights.
+    Kirchoff's Tree Matrix Theorem [1]_, [2]_ states that the determinant of any
+    cofactor of the Laplacian matrix of a graph is the number of spanning trees
+    in the graph. For a weighted Laplacian matrix, it is the sum across all
+    spanning trees of the multiplicative weight of each tree. That is, the
+    weight of each tree is the product of its edge weights.
+
+    For unweighted graphs, the total weight equals the number of spanning trees in `G`.
+
+    For directed graphs, the total weight follows by summing over all directed
+    spanning trees in `G` that start in the `root` node [3]_.
+
+    .. deprecated:: 3.3
+
+       ``total_spanning_tree_weight`` is deprecated and will be removed in v3.5.
+       Use ``nx.number_of_spanning_trees(G)`` instead.
 
     Parameters
     ----------
     G : NetworkX Graph
-        The graph to use Kirchhoff's theorem on.
 
-    weight : string or None
-        The key for the edge attribute holding the edge weight. If `None`, then
-        each edge is assumed to have a weight of 1 and this function returns the
-        total number of spanning trees in `G`.
+    weight : string or None, optional (default=None)
+        The key for the edge attribute holding the edge weight.
+        If None, then each edge has weight 1.
+
+    root : node (only required for directed graphs)
+       A node in the directed graph `G`.
 
     Returns
     -------
-    float
-        The sum of the total multiplicative weights for all spanning trees in `G`
+    total_weight : float
+        Undirected graphs:
+            The sum of the total multiplicative weights for all spanning trees in `G`.
+        Directed graphs:
+            The sum of the total multiplicative weights for all spanning trees of `G`,
+            rooted at node `root`.
+
+    Raises
+    ------
+    NetworkXPointlessConcept
+        If `G` does not contain any nodes.
+
+    NetworkXError
+        If the graph `G` is not (weakly) connected,
+        or if `G` is directed and the root node is not specified or not in G.
+
+    Examples
+    --------
+    >>> G = nx.complete_graph(5)
+    >>> round(nx.total_spanning_tree_weight(G))
+    125
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=2)
+    >>> G.add_edge(1, 3, weight=1)
+    >>> G.add_edge(2, 3, weight=1)
+    >>> round(nx.total_spanning_tree_weight(G, "weight"))
+    5
+
+    Notes
+    -----
+    Self-loops are excluded. Multi-edges are contracted in one edge
+    equal to the sum of the weights.
+
+    References
+    ----------
+    .. [1] Wikipedia
+       "Kirchhoff's theorem."
+       https://en.wikipedia.org/wiki/Kirchhoff%27s_theorem
+    .. [2] Kirchhoff, G. R.
+        Über die Auflösung der Gleichungen, auf welche man
+        bei der Untersuchung der linearen Vertheilung
+        Galvanischer Ströme geführt wird
+        Annalen der Physik und Chemie, vol. 72, pp. 497-508, 1847.
+    .. [3] Margoliash, J.
+        "Matrix-Tree Theorem for Directed Graphs"
+        https://www.math.uchicago.edu/~may/VIGRE/VIGRE2010/REUPapers/Margoliash.pdf
     """
-    import numpy as np
+    import warnings
+
+    warnings.warn(
+        (
+            "\n\ntotal_spanning_tree_weight is deprecated and will be removed in v3.5.\n"
+            "Use `nx.number_of_spanning_trees(G)` instead."
+        ),
+        category=DeprecationWarning,
+        stacklevel=3,
+    )
 
-    G_laplacian = nx.laplacian_matrix(G, weight=weight).toarray()
-    # Determinant ignoring first row and column
-    return float(abs(np.linalg.det(G_laplacian[1:, 1:])))
+    return nx.number_of_spanning_trees(G, weight=weight, root=root)
 
 
 ###############################################################################
@@ -313,7 +404,8 @@ def directed_laplacian_matrix(
     The result is always a symmetric matrix.
 
     This calculation uses the out-degree of the graph `G`. To use the
-    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+    in-degree for calculations instead, use `G.reverse(copy=False)` and
+    take the transpose.
 
     See Also
     --------
@@ -411,7 +503,8 @@ def directed_combinatorial_laplacian_matrix(
     The result is always a symmetric matrix.
 
     This calculation uses the out-degree of the graph `G`. To use the
-    in-degree for calculations instead, use `G.reverse(copy=False)` instead.
+    in-degree for calculations instead, use `G.reverse(copy=False)` and
+    take the transpose.
 
     See Also
     --------

From df96f4709b3b20f3e76aac4e30763882c5c4ed84 Mon Sep 17 00:00:00 2001
From: Vanshika Mishra <74042272+vanshika230@users.noreply.github.com>
Date: Mon, 4 Mar 2024 06:11:33 +0530
Subject: [PATCH 093/129] Improve test coverage for bipartite matrix.py (#7312)

* improve test coverage for matrix.py

* Update networkx/algorithms/bipartite/tests/test_matrix.py

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>

---------

Co-authored-by: Ross Barnowski <rossbar@berkeley.edu>
---
 networkx/algorithms/bipartite/tests/test_matrix.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/networkx/algorithms/bipartite/tests/test_matrix.py b/networkx/algorithms/bipartite/tests/test_matrix.py
index 393b71e7ca2..53d83115118 100644
--- a/networkx/algorithms/bipartite/tests/test_matrix.py
+++ b/networkx/algorithms/bipartite/tests/test_matrix.py
@@ -39,6 +39,11 @@ def test_biadjacency_matrix_order(self):
         M = bipartite.biadjacency_matrix(G, X, Y, weight="weight")
         assert M[1, 2] == 2
 
+    def test_biadjacency_matrix_empty_graph(self):
+        G = nx.empty_graph(2)
+        M = nx.bipartite.biadjacency_matrix(G, [0])
+        assert np.array_equal(M.toarray(), np.array([[0]]))
+
     def test_null_graph(self):
         with pytest.raises(nx.NetworkXError):
             bipartite.biadjacency_matrix(nx.Graph(), [])

From 8fe7f49b1ed9f6a7b31497c4d0888b4f261eed93 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Sun, 3 Mar 2024 16:44:38 -0800
Subject: [PATCH 094/129] Try/except intermittently failing basemaps in
 geospatial examples (#7324)

* Temporarily make poinst geospatial example non-executable.

Revert this when contextily basemap issue is improved.

* Revert "Temporarily rm geospatial examples to fix CI. (#7299)"

This reverts commit fce5d7d58d1a50ccc94419e888be3ff4fd8b61aa.

* Revert "Temporarily make poinst geospatial example non-executable."

This reverts commit 02927e3d3d3f49dc72e6c8c74fe2978a266f5c31.

* Try/except add_basemap in geospatial examples.
---
 examples/geospatial/{delaunay.py => plot_delaunay.py} |  6 +++++-
 examples/geospatial/{lines.py => plot_lines.py}       | 10 ++++++++--
 examples/geospatial/plot_points.py                    |  5 ++++-
 3 files changed, 17 insertions(+), 4 deletions(-)
 rename examples/geospatial/{delaunay.py => plot_delaunay.py} (96%)
 rename examples/geospatial/{lines.py => plot_lines.py} (94%)

diff --git a/examples/geospatial/delaunay.py b/examples/geospatial/plot_delaunay.py
similarity index 96%
rename from examples/geospatial/delaunay.py
rename to examples/geospatial/plot_delaunay.py
index edafe0635e1..799381fff74 100644
--- a/examples/geospatial/delaunay.py
+++ b/examples/geospatial/plot_delaunay.py
@@ -58,7 +58,11 @@
 
 # Now, we can plot with a nice basemap.
 ax = cells.plot(facecolor="lightblue", alpha=0.50, edgecolor="cornsilk", linewidth=2)
-add_basemap(ax)
+try:  # Try-except for issues with timeout/parsing failures in CI
+    add_basemap(ax)
+except:
+    pass
+
 ax.axis("off")
 nx.draw(
     delaunay_graph,
diff --git a/examples/geospatial/lines.py b/examples/geospatial/plot_lines.py
similarity index 94%
rename from examples/geospatial/lines.py
rename to examples/geospatial/plot_lines.py
index 616db374369..3de10223b3f 100644
--- a/examples/geospatial/lines.py
+++ b/examples/geospatial/plot_lines.py
@@ -76,7 +76,10 @@
 for i, facet in enumerate(ax):
     facet.set_title(("Streets", "Graph")[i])
     facet.axis("off")
-    add_basemap(facet)
+    try:  # For issues with downloading/parsing in CI
+        add_basemap(facet)
+    except:
+        pass
 nx.draw(
     G_primal, {n: [n[0], n[1]] for n in list(G_primal.nodes)}, ax=ax[1], node_size=50
 )
@@ -92,7 +95,10 @@
 for i, facet in enumerate(ax):
     facet.set_title(("Streets", "Graph")[i])
     facet.axis("off")
-    add_basemap(facet)
+    try:  # For issues with downloading/parsing in CI
+        add_basemap(facet)
+    except:
+        pass
 nx.draw(G_dual, {n: [n[0], n[1]] for n in list(G_dual.nodes)}, ax=ax[1], node_size=50)
 plt.show()
 
diff --git a/examples/geospatial/plot_points.py b/examples/geospatial/plot_points.py
index 7d9d99df826..7517069cafa 100644
--- a/examples/geospatial/plot_points.py
+++ b/examples/geospatial/plot_points.py
@@ -51,7 +51,10 @@
 f, ax = plt.subplots(1, 2, figsize=(8, 4))
 for i, facet in enumerate(ax):
     cases.plot(marker=".", color="orangered", ax=facet)
-    add_basemap(facet)
+    try:  # For issues with downloading/parsing basemaps in CI
+        add_basemap(facet)
+    except:
+        pass
     facet.set_title(("KNN-3", "50-meter Distance Band")[i])
     facet.axis("off")
 nx.draw(knn_graph, positions, ax=ax[0], node_size=5, node_color="b")

From 7e97d4c040a39cc4cbe22b2ab78c10f028610bb9 Mon Sep 17 00:00:00 2001
From: BucketHeadP65 <104688161+BucketHeadP65@users.noreply.github.com>
Date: Mon, 4 Mar 2024 05:46:41 +0200
Subject: [PATCH 095/129] Update __init__.py (#7320)

* Update __init__.py

* Update __init__.py corrected import order
---
 networkx/generators/__init__.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/networkx/generators/__init__.py b/networkx/generators/__init__.py
index 7a1adc42a7b..324d82b7e32 100644
--- a/networkx/generators/__init__.py
+++ b/networkx/generators/__init__.py
@@ -12,6 +12,7 @@
 from networkx.generators.ego import *
 from networkx.generators.expanders import *
 from networkx.generators.geometric import *
+from networkx.generators.harary_graph import *
 from networkx.generators.internet_as_graphs import *
 from networkx.generators.intersection import *
 from networkx.generators.interval_graph import *

From 41fd8df916c65c60f7403031a583f0ea5d7a8eec Mon Sep 17 00:00:00 2001
From: Aaron Z <40212329+aaronzo@users.noreply.github.com>
Date: Tue, 5 Mar 2024 05:23:31 +0000
Subject: [PATCH 096/129] add seed to `nx.generate_random_paths` (#7332)

add seed to generate_random_paths
---
 networkx/algorithms/similarity.py            | 15 ++++++++++++---
 networkx/algorithms/tests/test_similarity.py |  4 +---
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/networkx/algorithms/similarity.py b/networkx/algorithms/similarity.py
index 765849984ea..24f303b13c9 100644
--- a/networkx/algorithms/similarity.py
+++ b/networkx/algorithms/similarity.py
@@ -20,6 +20,7 @@
 from itertools import product
 
 import networkx as nx
+from networkx.utils import np_random_state
 
 __all__ = [
     "graph_edit_distance",
@@ -1662,9 +1663,10 @@ def panther_similarity(
     return top_k_with_val
 
 
+@np_random_state(5)
 @nx._dispatchable(edge_attrs="weight")
 def generate_random_paths(
-    G, sample_size, path_length=5, index_map=None, weight="weight"
+    G, sample_size, path_length=5, index_map=None, weight="weight", seed=None
 ):
     """Randomly generate `sample_size` paths of length `path_length`.
 
@@ -1685,6 +1687,9 @@ def generate_random_paths(
     weight : string or None, optional (default="weight")
         The name of an edge attribute that holds the numerical value
         used as a weight. If None then each edge has weight 1.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
 
     Returns
     -------
@@ -1718,6 +1723,10 @@ def generate_random_paths(
     """
     import numpy as np
 
+    randint_fn = (
+        seed.integers if isinstance(seed, np.random.Generator) else seed.randint
+    )
+
     # Calculate transition probabilities between
     # every pair of vertices according to Eq. (3)
     adj_mat = nx.to_numpy_array(G, weight=weight)
@@ -1729,7 +1738,7 @@ def generate_random_paths(
 
     for path_index in range(sample_size):
         # Sample current vertex v = v_i uniformly at random
-        node_index = np.random.randint(0, high=num_nodes)
+        node_index = randint_fn(num_nodes)
         node = node_map[node_index]
 
         # Add v into p_r and add p_r into the path set
@@ -1747,7 +1756,7 @@ def generate_random_paths(
         for _ in range(path_length):
             # Randomly sample a neighbor (v_j) according
             # to transition probabilities from ``node`` (v) to its neighbors
-            nbr_index = np.random.choice(
+            nbr_index = seed.choice(
                 num_nodes, p=transition_probabilities[starting_index]
             )
 
diff --git a/networkx/algorithms/tests/test_similarity.py b/networkx/algorithms/tests/test_similarity.py
index 420c709c173..3836ccfe182 100644
--- a/networkx/algorithms/tests/test_similarity.py
+++ b/networkx/algorithms/tests/test_similarity.py
@@ -845,8 +845,6 @@ def test_panther_similarity_isolated(self):
             nx.panther_similarity(G, source=1)
 
     def test_generate_random_paths_unweighted(self):
-        np.random.seed(42)
-
         index_map = {}
         num_paths = 10
         path_length = 2
@@ -857,7 +855,7 @@ def test_generate_random_paths_unweighted(self):
         G.add_edge(1, 2)
         G.add_edge(2, 4)
         paths = nx.generate_random_paths(
-            G, num_paths, path_length=path_length, index_map=index_map
+            G, num_paths, path_length=path_length, index_map=index_map, seed=42
         )
         expected_paths = [
             [3, 0, 3],

From 1f8d279e230e9930a27fe27466ddd07a017a597e Mon Sep 17 00:00:00 2001
From: Erik Welch <erik.n.welch@gmail.com>
Date: Mon, 4 Mar 2024 23:45:44 -0600
Subject: [PATCH 097/129] Allow backends to implement `should_run` (#7257)

* Allow backends to implement `should_run`

* Handle str return types for `can_run` and `should_run`
---
 networkx/utils/backends.py | 45 ++++++++++++++++++++++++++++++++++----
 1 file changed, 41 insertions(+), 4 deletions(-)

diff --git a/networkx/utils/backends.py b/networkx/utils/backends.py
index 1533dc55435..6c1ab0498b1 100644
--- a/networkx/utils/backends.py
+++ b/networkx/utils/backends.py
@@ -78,6 +78,17 @@ class WrappedSparse:
 If a backend only partially implements some algorithms, it can define
 a ``can_run(name, args, kwargs)`` function that returns True or False
 indicating whether it can run the algorithm with the given arguments.
+It may also return a string indicating why the algorithm can't be run;
+this string may be used in the future to give helpful info to the user.
+
+A backend may also define ``should_run(name, args, kwargs)`` that is similar
+to ``can_run``, but answers whether the backend *should* be run (converting
+if necessary). Like ``can_run``, it receives the original arguments so it
+can decide whether it should be run by inspecting the arguments. ``can_run``
+runs before ``should_run``, so ``should_run`` may assume ``can_run`` is True.
+
+If not implemented by the backend, ``can_run`` and ``should_run`` are
+assumed to always return True if the backend implements the algorithm.
 
 A special ``on_start_tests(items)`` function may be defined by the backend.
 It will be called with the list of NetworkX tests discovered. Each item
@@ -135,10 +146,18 @@ def _get_backends(group, *, load_and_call=False):
 _loaded_backends = {}  # type: ignore[var-annotated]
 
 
+def _always_run(name, args, kwargs):
+    return True
+
+
 def _load_backend(backend_name):
     if backend_name in _loaded_backends:
         return _loaded_backends[backend_name]
     rv = _loaded_backends[backend_name] = backends[backend_name].load()
+    if not hasattr(rv, "can_run"):
+        rv.can_run = _always_run
+    if not hasattr(rv, "should_run"):
+        rv.should_run = _always_run
     return rv
 
 
@@ -579,6 +598,7 @@ def __call__(self, /, *args, backend=None, **kwargs):
         # Only networkx graphs; try to convert and run with a backend with automatic
         # conversion, but don't do this by default for graph generators or loaders,
         # or if the functions mutates an input graph or returns a graph.
+        # Only convert and run if `backend.should_run(...)` returns True.
         if (
             not self._returns_graph
             and (
@@ -603,7 +623,7 @@ def __call__(self, /, *args, backend=None, **kwargs):
         ):
             # Should we warn or log if we don't convert b/c the input will be mutated?
             for backend_name in self._automatic_backends:
-                if self._can_backend_run(backend_name, *args, **kwargs):
+                if self._should_backend_run(backend_name, *args, **kwargs):
                     return self._convert_and_call(
                         backend_name,
                         args,
@@ -614,10 +634,27 @@ def __call__(self, /, *args, backend=None, **kwargs):
         return self.orig_func(*args, **kwargs)
 
     def _can_backend_run(self, backend_name, /, *args, **kwargs):
-        """Can the specified backend run this algorithms with these arguments?"""
+        """Can the specified backend run this algorithm with these arguments?"""
+        backend = _load_backend(backend_name)
+        # `backend.can_run` and `backend.should_run` may return strings that describe
+        # why they can't or shouldn't be run. We plan to use the strings in the future.
+        return (
+            hasattr(backend, self.name)
+            and (can_run := backend.can_run(self.name, args, kwargs))
+            and not isinstance(can_run, str)
+        )
+
+    def _should_backend_run(self, backend_name, /, *args, **kwargs):
+        """Can/should the specified backend run this algorithm with these arguments?"""
         backend = _load_backend(backend_name)
-        return hasattr(backend, self.name) and (
-            not hasattr(backend, "can_run") or backend.can_run(self.name, args, kwargs)
+        # `backend.can_run` and `backend.should_run` may return strings that describe
+        # why they can't or shouldn't be run. We plan to use the strings in the future.
+        return (
+            hasattr(backend, self.name)
+            and (can_run := backend.can_run(self.name, args, kwargs))
+            and not isinstance(can_run, str)
+            and (should_run := backend.should_run(self.name, args, kwargs))
+            and not isinstance(should_run, str)
         )
 
     def _convert_arguments(self, backend_name, args, kwargs):

From 15df9159e8d952e114d7c1dfa002ff29b9d5b9ac Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Mon, 4 Mar 2024 22:29:32 -0800
Subject: [PATCH 098/129] Un-dispatch coloring strategies. (#7329)

---
 networkx/algorithms/coloring/greedy_coloring.py | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/networkx/algorithms/coloring/greedy_coloring.py b/networkx/algorithms/coloring/greedy_coloring.py
index 661f14e0149..61bc953673f 100644
--- a/networkx/algorithms/coloring/greedy_coloring.py
+++ b/networkx/algorithms/coloring/greedy_coloring.py
@@ -20,7 +20,6 @@
 ]
 
 
-@nx._dispatchable
 def strategy_largest_first(G, colors):
     """Returns a list of the nodes of ``G`` in decreasing order by
     degree.
@@ -32,7 +31,6 @@ def strategy_largest_first(G, colors):
 
 
 @py_random_state(2)
-@nx._dispatchable
 def strategy_random_sequential(G, colors, seed=None):
     """Returns a random permutation of the nodes of ``G`` as a list.
 
@@ -47,7 +45,6 @@ def strategy_random_sequential(G, colors, seed=None):
     return nodes
 
 
-@nx._dispatchable
 def strategy_smallest_last(G, colors):
     """Returns a deque of the nodes of ``G``, "smallest" last.
 
@@ -121,7 +118,6 @@ def _maximal_independent_set(G):
     return result
 
 
-@nx._dispatchable
 def strategy_independent_set(G, colors):
     """Uses a greedy independent set removal strategy to determine the
     colors.
@@ -146,7 +142,6 @@ def strategy_independent_set(G, colors):
         yield from nodes
 
 
-@nx._dispatchable
 def strategy_connected_sequential_bfs(G, colors):
     """Returns an iterable over nodes in ``G`` in the order given by a
     breadth-first traversal.
@@ -160,7 +155,6 @@ def strategy_connected_sequential_bfs(G, colors):
     return strategy_connected_sequential(G, colors, "bfs")
 
 
-@nx._dispatchable
 def strategy_connected_sequential_dfs(G, colors):
     """Returns an iterable over nodes in ``G`` in the order given by a
     depth-first traversal.
@@ -174,7 +168,6 @@ def strategy_connected_sequential_dfs(G, colors):
     return strategy_connected_sequential(G, colors, "dfs")
 
 
-@nx._dispatchable
 def strategy_connected_sequential(G, colors, traversal="bfs"):
     """Returns an iterable over nodes in ``G`` in the order given by a
     breadth-first or depth-first traversal.
@@ -207,7 +200,6 @@ def strategy_connected_sequential(G, colors, traversal="bfs"):
             yield end
 
 
-@nx._dispatchable
 def strategy_saturation_largest_first(G, colors):
     """Iterates over all the nodes of ``G`` in "saturation order" (also
     known as "DSATUR").

From e005b692785e8cfa6dbf4458aa46bc4ab757aa5c Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Mon, 4 Mar 2024 22:30:36 -0800
Subject: [PATCH 099/129] Undo change in return type of
 `single_target_shortest_path_length` (#7327)

Fixup tests.
---
 networkx/algorithms/shortest_paths/tests/test_unweighted.py | 4 ++--
 networkx/algorithms/shortest_paths/unweighted.py            | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/networkx/algorithms/shortest_paths/tests/test_unweighted.py b/networkx/algorithms/shortest_paths/tests/test_unweighted.py
index ec0b3f757ed..e2d999518a5 100644
--- a/networkx/algorithms/shortest_paths/tests/test_unweighted.py
+++ b/networkx/algorithms/shortest_paths/tests/test_unweighted.py
@@ -92,9 +92,9 @@ def test_single_target_shortest_path(self):
     def test_single_target_shortest_path_length(self):
         pl = nx.single_target_shortest_path_length
         lengths = {0: 0, 1: 1, 2: 2, 3: 3, 4: 3, 5: 2, 6: 1}
-        assert pl(self.cycle, 0) == lengths
+        assert dict(pl(self.cycle, 0)) == lengths
         lengths = {0: 0, 1: 6, 2: 5, 3: 4, 4: 3, 5: 2, 6: 1}
-        assert pl(self.directed_cycle, 0) == lengths
+        assert dict(pl(self.directed_cycle, 0)) == lengths
         # test missing targets
         target = 8
         with pytest.raises(nx.NodeNotFound, match=f"Target {target} is not in G"):
diff --git a/networkx/algorithms/shortest_paths/unweighted.py b/networkx/algorithms/shortest_paths/unweighted.py
index c7eea6fc625..bb587bba991 100644
--- a/networkx/algorithms/shortest_paths/unweighted.py
+++ b/networkx/algorithms/shortest_paths/unweighted.py
@@ -117,7 +117,7 @@ def single_target_shortest_path_length(G, target, cutoff=None):
     Examples
     --------
     >>> G = nx.path_graph(5, create_using=nx.DiGraph())
-    >>> length = nx.single_target_shortest_path_length(G, 4)
+    >>> length = dict(nx.single_target_shortest_path_length(G, 4))
     >>> length[0]
     4
     >>> for node in range(5):
@@ -151,7 +151,7 @@ def single_target_shortest_path_length(G, target, cutoff=None):
     nextlevel = [target]
     # for version 3.3 we will return a dict like this:
     # return dict(_single_shortest_path_length(adj, nextlevel, cutoff))
-    return dict(_single_shortest_path_length(adj, nextlevel, cutoff))
+    return _single_shortest_path_length(adj, nextlevel, cutoff)
 
 
 @nx._dispatchable

From 19e6bc740319bcd428334d555525890a4c88ec73 Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Mon, 4 Mar 2024 22:35:03 -0800
Subject: [PATCH 100/129] Update docstring example with future-proof pandas
 assignment. (#7323)

* Update docstring example with future-proof pandas assignment.

* Rm unnecessary import.

Co-authored-by: Dan Schult <dschult@colgate.edu>

---------

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/convert_matrix.py | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/networkx/convert_matrix.py b/networkx/convert_matrix.py
index 2fc1e784f5b..6165ac18e31 100644
--- a/networkx/convert_matrix.py
+++ b/networkx/convert_matrix.py
@@ -101,20 +101,21 @@ def to_pandas_adjacency(
     diagonal matrix entry value to the weight attribute of the edge
     (or the number 1 if the edge has no weight attribute).  If the
     alternate convention of doubling the edge weight is desired the
-    resulting Pandas DataFrame can be modified as follows:
-
-    >>> import pandas as pd
-    >>> pd.options.display.max_columns = 20
-    >>> import numpy as np
-    >>> G = nx.Graph([(1, 1)])
-    >>> df = nx.to_pandas_adjacency(G, dtype=int)
-    >>> df
-       1
-    1  1
-    >>> df.values[np.diag_indices_from(df)] *= 2
-    >>> df
-       1
-    1  2
+    resulting Pandas DataFrame can be modified as follows::
+
+        >>> import pandas as pd
+        >>> G = nx.Graph([(1, 1), (2, 2)])
+        >>> df = nx.to_pandas_adjacency(G)
+        >>> df
+             1    2
+        1  1.0  0.0
+        2  0.0  1.0
+        >>> diag_idx = list(range(len(df)))
+        >>> df.iloc[diag_idx, diag_idx] *= 2
+        >>> df
+             1    2
+        1  2.0  0.0
+        2  0.0  2.0
 
     Examples
     --------

From 91337d52979b7673651267cd8e6c6d44c489b5df Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Wed, 6 Mar 2024 11:37:33 -0800
Subject: [PATCH 101/129] Remove animation from spectral clustering example to
 improve performance (#7328)

* Rm 3d animation from spectral clustering example.

* Add xref to 3D examples to illustrate how to animate 3D viz.
* Vastly improves (>100x) example runtime.

* Add sphinx-gallery config to allow xrefs.
---
 doc/conf.py                                   |  1 +
 ...ge_segmentation_spectral_graph_partiion.py | 74 +++----------------
 2 files changed, 10 insertions(+), 65 deletions(-)

diff --git a/doc/conf.py b/doc/conf.py
index e2eb2a547c9..cdd04b9fe52 100644
--- a/doc/conf.py
+++ b/doc/conf.py
@@ -54,6 +54,7 @@
     "image_scrapers": ("matplotlib",),
     "matplotlib_animations": True,
     "plot_gallery": "True",
+    "reference_url": {"sphinx_gallery": None},
 }
 # Add pygraphviz png scraper, if available
 try:
diff --git a/examples/algorithms/plot_image_segmentation_spectral_graph_partiion.py b/examples/algorithms/plot_image_segmentation_spectral_graph_partiion.py
index f2787a2b4c8..197b86d1496 100644
--- a/examples/algorithms/plot_image_segmentation_spectral_graph_partiion.py
+++ b/examples/algorithms/plot_image_segmentation_spectral_graph_partiion.py
@@ -1,12 +1,16 @@
 """
-=====================================================
+==================================================
 Image Segmentation via Spectral Graph Partitioning
-=====================================================
-Example of partitioning a undirected graph obtained by `k-neighbors`
+==================================================
+
+Example of partitioning a undirected graph obtained by ``k-neighbors``
 from an RGB image into two subgraphs using spectral clustering
 illustrated by 3D plots of the original labeled data points in RGB 3D space
 vs the bi-partition marking performed by graph partitioning via spectral clustering.
-All 3D plots and animations use the 3D spectral layout.
+All 3D plots use the 3D spectral layout.
+
+See :ref:`sphx_glr_auto_examples_3d_drawing` for recipes to create 3D animations
+from these visualizations.
 """
 import numpy as np
 import networkx as nx
@@ -15,7 +19,7 @@
 from matplotlib.lines import Line2D
 from sklearn.cluster import SpectralClustering
 
-# sphinx_gallery_thumbnail_number = 4
+# sphinx_gallery_thumbnail_number = 3
 
 ###############################################################################
 # Create an example 3D dataset "The Rings".
@@ -129,40 +133,6 @@ def _scatter_plot(ax, X, array_of_markers, axis_plot=True):
 
 plt.show()
 
-###############################################################################
-# Generate the rotating animation of the clustered data.
-# ------------------------------------------------------
-# The data points are marked according to clustering and rotated
-# in the 3D animation.
-
-
-def _init():
-    ax.clear()
-    _scatter_plot(ax, X, array_of_markers)
-    ax.grid(False)
-    ax.set_axis_off()
-    ax.view_init(elev=6.0, azim=-22.0)
-
-
-def _frame_update(index):
-    ax.view_init(6.0 + index * 0.2, -22.0 + index * 0.5)
-
-
-fig = plt.figure(layout="tight")
-ax = fig.add_subplot(111, projection="3d")
-ax.grid(False)
-ax.set_axis_off()
-ani = animation.FuncAnimation(
-    fig,
-    _frame_update,
-    init_func=_init,
-    interval=50,
-    cache_frame_data=False,
-    frames=100,
-)
-
-plt.show()
-
 
 ###############################################################################
 # Generate the plots of the graph.
@@ -217,29 +187,3 @@ def _3d_graph_plot(ax):
 _3d_graph_plot(ax1)
 plt.tight_layout()
 plt.show()
-
-###############################################################################
-# Generate the rotating 3D animation of the graph.
-# ------------------------------------------------
-# The nodes of the graph are marked according to clustering.
-# The graph is rotated in the 3D animation.
-
-
-def _frame_update(index):
-    ax.view_init(100.0 + index * 0.7, -100.0 + index * 0.5)
-
-
-fig = plt.figure(layout="tight")
-ax = fig.add_subplot(111, projection="3d")
-ax.grid(False)
-ax.set_axis_off()
-_3d_graph_plot(ax)
-ani = animation.FuncAnimation(
-    fig,
-    _frame_update,
-    interval=50,
-    cache_frame_data=False,
-    frames=100,
-)
-
-plt.show()

From 9e72994ccd96770cbde0ac548eb2db86adc6394b Mon Sep 17 00:00:00 2001
From: Matt Schwennesen <mjschwenne@gmail.com>
Date: Thu, 7 Mar 2024 04:47:53 +0000
Subject: [PATCH 102/129] Add new test result to `test_asadpour_tsp` and change
 `linprog` method (#7335)

fix linprog method, add new test result
---
 .../approximation/tests/test_traveling_salesman.py   | 12 +++++++++---
 .../algorithms/approximation/traveling_salesman.py   |  4 +++-
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/networkx/algorithms/approximation/tests/test_traveling_salesman.py b/networkx/algorithms/approximation/tests/test_traveling_salesman.py
index ccb553e1cc7..539b243549a 100644
--- a/networkx/algorithms/approximation/tests/test_traveling_salesman.py
+++ b/networkx/algorithms/approximation/tests/test_traveling_salesman.py
@@ -756,9 +756,15 @@ def fixed_asadpour(G, weight):
     # the shortest path between those vertices, allowing vertices to appear more
     # than once.
     #
-    # However, we are using a fixed random number generator so we know what the
-    # expected tour is.
-    expected_tours = [[1, 4, 5, 0, 2, 3, 2, 1], [3, 2, 0, 1, 4, 5, 3]]
+    # Even though we are using a fixed seed, multiple tours have been known to
+    # be returned. The first two are from the original delevopment of this test,
+    # and the third one from issue #5913 on GitHub. If other tours are returned,
+    # add it on the list of expected tours.
+    expected_tours = [
+        [1, 4, 5, 0, 2, 3, 2, 1],
+        [3, 2, 0, 1, 4, 5, 3],
+        [3, 2, 1, 0, 5, 4, 3],
+    ]
 
     assert tour in expected_tours
 
diff --git a/networkx/algorithms/approximation/traveling_salesman.py b/networkx/algorithms/approximation/traveling_salesman.py
index f3fae97e8ef..7501daf41f5 100644
--- a/networkx/algorithms/approximation/traveling_salesman.py
+++ b/networkx/algorithms/approximation/traveling_salesman.py
@@ -683,7 +683,9 @@ def direction_of_ascent():
                     a_eq[n_count][arb_count] = deg - 2
                     n_count -= 1
                 a_eq[len(G)][arb_count] = 1
-            program_result = optimize.linprog(c, A_eq=a_eq, b_eq=b_eq)
+            program_result = optimize.linprog(
+                c, A_eq=a_eq, b_eq=b_eq, method="highs-ipm"
+            )
             # If the constants exist, then the direction of ascent doesn't
             if program_result.success:
                 # There is no direction of ascent

From e31af672f25a866ea65a6c70fdd2bef1d550d330 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Fri, 8 Sep 2023 09:16:15 -0400
Subject: [PATCH 103/129] adding tree broadcast algorithm

---
 networkx/algorithms/approximation/__init__.py |  1 +
 .../algorithms/approximation/broadcasting.py  | 69 +++++++++++++++++++
 .../approximation/tests/test_broadcasting.py  | 40 +++++++++++
 3 files changed, 110 insertions(+)
 create mode 100644 networkx/algorithms/approximation/broadcasting.py
 create mode 100644 networkx/algorithms/approximation/tests/test_broadcasting.py

diff --git a/networkx/algorithms/approximation/__init__.py b/networkx/algorithms/approximation/__init__.py
index e39dc00aa25..0e328a9ef36 100644
--- a/networkx/algorithms/approximation/__init__.py
+++ b/networkx/algorithms/approximation/__init__.py
@@ -9,6 +9,7 @@
 ``from networkx.algorithms.approximation import function_name``.
 
 """
+from networkx.algorithms.approximation.broadcasting import *
 from networkx.algorithms.approximation.clustering_coefficient import *
 from networkx.algorithms.approximation.clique import *
 from networkx.algorithms.approximation.connectivity import *
diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
new file mode 100644
index 00000000000..a4417123541
--- /dev/null
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -0,0 +1,69 @@
+import networkx as nx
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "tree_broadcast",
+]
+
+
+def update_broadcast_label(G, U, v):
+    adj = [u for u in G.neighbors(v) if u in U]
+    adj.sort(key=lambda u: G.nodes[u]["value"], reverse=True)
+    return max([G.nodes[u]["value"] + i for i, u in enumerate(adj, start=1)])
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def tree_broadcast(G):
+    """
+    This functions implements a linear algorithm for determining the minimum broadcast time
+    on any tree. As a byproduct, it can also find a vertex which acts as the broadcast center,
+    i.e., the vertex where the broadcast begins.
+    """
+    # Remove selfloops if necessary
+    loop_nodes = nx.nodes_with_selfloops(G)
+    try:
+        node = next(loop_nodes)
+    except StopIteration:
+        pass
+    else:
+        G = G.copy()
+        G.remove_edge(node, node)
+        G.remove_edges_from((n, n) for n in loop_nodes)
+
+    if G.number_of_nodes() == 2:
+        return 1
+    elif G.number_of_nodes() == 1:
+        return 0
+
+    U = {node for node in G.nodes() if G.degree(node) == 1}
+    for u in U:
+        G.nodes[u]["value"] = 0
+
+    T = G.copy()
+    T.remove_nodes_from(U)
+
+    W = {node for node in T.nodes() if T.degree(node) == 1}
+
+    for w in W:
+        G.nodes[w]["value"] = G.degree[w] - 1
+
+    while T.number_of_nodes() >= 2:
+        w = min(W, key=lambda n: G.nodes[n]["value"])
+        try:
+            v = next(T.neighbors(w))
+            print(f"Adjacent vertex of vertex {w}: {v}")
+        except StopIteration:
+            print(f"Vertex {v} has no adjacent vertices.")
+
+        U.add(w)
+        W.remove(w)
+        T.remove_node(w)
+
+        if T.degree(v) == 1:
+            # update t(v)
+            G.nodes[v]["value"] = update_broadcast_label(G, U, v)
+            print(f"Updating broadcast time of vertex {v} to {G.nodes[v]['value']}")
+            W.add(v)
+
+    return update_broadcast_label(G, U, v)
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
new file mode 100644
index 00000000000..cc86d650c00
--- /dev/null
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -0,0 +1,40 @@
+"""Unit tests for the broadcasting module."""
+import random
+
+import pytest
+
+import networkx as nx
+import networkx.algorithms.approximation as nx_app
+
+
+def test_example_tree_broadcast():
+    """
+    Test the BROADCAST algorithm on the example in the paper titled: "Information Dissemination in Trees"
+    """
+    G = nx.Graph()
+    G.add_nodes_from(range(21))
+    edge_list = [
+        (0, 1),
+        (1, 2),
+        (2, 7),
+        (3, 4),
+        (5, 4),
+        (4, 7),
+        (6, 7),
+        (7, 9),
+        (8, 9),
+        (9, 13),
+        (13, 14),
+        (14, 15),
+        (14, 16),
+        (14, 17),
+        (13, 11),
+        (11, 10),
+        (11, 12),
+        (13, 18),
+        (18, 19),
+        (18, 20),
+    ]
+    G.add_edges_from(edge_list)
+    b_G = nx_app.tree_broadcast(G)
+    assert b_G == 6

From 1fcb41e88f426d5b620d86b404d7cee5dcf8b239 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Wed, 13 Sep 2023 22:56:23 -0400
Subject: [PATCH 104/129] adding steps and more tests

---
 .../algorithms/approximation/broadcasting.py  | 29 +++++++++++++++++--
 .../approximation/tests/test_broadcasting.py  | 13 ++++++++-
 2 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index a4417123541..1c7ca5ce0dd 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -19,6 +19,21 @@ def tree_broadcast(G):
     This functions implements a linear algorithm for determining the minimum broadcast time
     on any tree. As a byproduct, it can also find a vertex which acts as the broadcast center,
     i.e., the vertex where the broadcast begins.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+
+    Returns
+    -------
+    b_T : int
+        Optimal Broadcast time of a tree
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
     """
     # Remove selfloops if necessary
     loop_nodes = nx.nodes_with_selfloops(G)
@@ -31,24 +46,27 @@ def tree_broadcast(G):
         G.remove_edge(node, node)
         G.remove_edges_from((n, n) for n in loop_nodes)
 
+    # step 0
     if G.number_of_nodes() == 2:
         return 1
     elif G.number_of_nodes() == 1:
         return 0
 
+    # step 1
     U = {node for node in G.nodes() if G.degree(node) == 1}
     for u in U:
         G.nodes[u]["value"] = 0
-
     T = G.copy()
     T.remove_nodes_from(U)
 
+    # step 2
     W = {node for node in T.nodes() if T.degree(node) == 1}
-
     for w in W:
         G.nodes[w]["value"] = G.degree[w] - 1
 
+    # step 3
     while T.number_of_nodes() >= 2:
+        # step 4
         w = min(W, key=lambda n: G.nodes[n]["value"])
         try:
             v = next(T.neighbors(w))
@@ -56,14 +74,19 @@ def tree_broadcast(G):
         except StopIteration:
             print(f"Vertex {v} has no adjacent vertices.")
 
+        # step 5
         U.add(w)
         W.remove(w)
         T.remove_node(w)
 
+        # step 6
         if T.degree(v) == 1:
             # update t(v)
             G.nodes[v]["value"] = update_broadcast_label(G, U, v)
             print(f"Updating broadcast time of vertex {v} to {G.nodes[v]['value']}")
             W.add(v)
 
-    return update_broadcast_label(G, U, v)
+    # step 7
+    v = list(T.nodes())[0]
+    b_T = update_broadcast_label(G, U, v)
+    return b_T
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index cc86d650c00..e14a578d006 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -1,5 +1,5 @@
 """Unit tests for the broadcasting module."""
-import random
+import math
 
 import pytest
 
@@ -38,3 +38,14 @@ def test_example_tree_broadcast():
     G.add_edges_from(edge_list)
     b_G = nx_app.tree_broadcast(G)
     assert b_G == 6
+
+
+def test_path_broadcast():
+    for i in range(2, 12):
+        G = nx.path_graph(i)
+        assert nx_app.tree_broadcast(G) == math.ceil(i / 2)
+
+    # test base case when the graph has only one node
+    H = nx.Graph()
+    H.add_node(0)
+    assert nx_app.tree_broadcast(H) == 0

From 8a3c5c3f07049591c546b81891226ba71119637d Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Thu, 14 Sep 2023 15:41:08 -0400
Subject: [PATCH 105/129] adding citation and assertion

---
 networkx/algorithms/approximation/broadcasting.py    | 12 +++++++++---
 .../approximation/tests/test_broadcasting.py         |  2 --
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 1c7ca5ce0dd..068e5f54a8b 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -17,7 +17,7 @@ def update_broadcast_label(G, U, v):
 def tree_broadcast(G):
     """
     This functions implements a linear algorithm for determining the minimum broadcast time
-    on any tree. As a byproduct, it can also find a vertex which acts as the broadcast center,
+    on any tree [1]_. As a byproduct, it can also find a vertex which acts as the broadcast center,
     i.e., the vertex where the broadcast begins.
 
     Parameters
@@ -34,6 +34,11 @@ def tree_broadcast(G):
     ------
     NetworkXNotImplemented
         If the graph is directed or is a multigraph.
+
+    References
+    ----------
+    .. [1] Slater, P.J., Cockayne, E.J., Hedetniemi, S.T,
+       Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
     """
     # Remove selfloops if necessary
     loop_nodes = nx.nodes_with_selfloops(G)
@@ -46,6 +51,9 @@ def tree_broadcast(G):
         G.remove_edge(node, node)
         G.remove_edges_from((n, n) for n in loop_nodes)
 
+    # Assert that the graph G has no cycles
+    assert nx.is_tree(G), "The graph G is not a tree"
+
     # step 0
     if G.number_of_nodes() == 2:
         return 1
@@ -70,7 +78,6 @@ def tree_broadcast(G):
         w = min(W, key=lambda n: G.nodes[n]["value"])
         try:
             v = next(T.neighbors(w))
-            print(f"Adjacent vertex of vertex {w}: {v}")
         except StopIteration:
             print(f"Vertex {v} has no adjacent vertices.")
 
@@ -83,7 +90,6 @@ def tree_broadcast(G):
         if T.degree(v) == 1:
             # update t(v)
             G.nodes[v]["value"] = update_broadcast_label(G, U, v)
-            print(f"Updating broadcast time of vertex {v} to {G.nodes[v]['value']}")
             W.add(v)
 
     # step 7
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index e14a578d006..40e4d2956c2 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -1,8 +1,6 @@
 """Unit tests for the broadcasting module."""
 import math
 
-import pytest
-
 import networkx as nx
 import networkx.algorithms.approximation as nx_app
 

From e6fb0ffc4119e31fc26e447506644f5344d3e0cc Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Tue, 26 Sep 2023 12:47:41 -0400
Subject: [PATCH 106/129] applying first set of suggestions

---
 .../algorithms/approximation/broadcasting.py  | 37 ++++++++-----------
 .../approximation/tests/test_broadcasting.py  | 10 ++---
 2 files changed, 20 insertions(+), 27 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 068e5f54a8b..f668f2f9386 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -1,20 +1,20 @@
 import networkx as nx
+from networkx import NetworkXError
 from networkx.utils import not_implemented_for
 
 __all__ = [
-    "tree_broadcast",
+    "tree_broadcast_time",
 ]
 
 
-def update_broadcast_label(G, U, v):
-    adj = [u for u in G.neighbors(v) if u in U]
-    adj.sort(key=lambda u: G.nodes[u]["value"], reverse=True)
-    return max([G.nodes[u]["value"] + i for i, u in enumerate(adj, start=1)])
+def _get_max_broadcast_value(G, U, v, values):
+    adj = sorted(set(G.neighbors(v)) & U, key=lambda u: values[u], reverse=True)
+    return max(values[u] + i for i, u in enumerate(adj, start=1))
 
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-def tree_broadcast(G):
+def tree_broadcast_time(G):
     """
     This functions implements a linear algorithm for determining the minimum broadcast time
     on any tree [1]_. As a byproduct, it can also find a vertex which acts as the broadcast center,
@@ -52,8 +52,8 @@ def tree_broadcast(G):
         G.remove_edges_from((n, n) for n in loop_nodes)
 
     # Assert that the graph G has no cycles
-    assert nx.is_tree(G), "The graph G is not a tree"
-
+    if not nx.is_tree(G):
+        NetworkXError("Your graph is not a tree")
     # step 0
     if G.number_of_nodes() == 2:
         return 1
@@ -61,25 +61,20 @@ def tree_broadcast(G):
         return 0
 
     # step 1
-    U = {node for node in G.nodes() if G.degree(node) == 1}
-    for u in U:
-        G.nodes[u]["value"] = 0
+    U = {node for node, deg in G.degree if deg == 1}
+    values = {n: 0 for n in U}
     T = G.copy()
     T.remove_nodes_from(U)
 
     # step 2
-    W = {node for node in T.nodes() if T.degree(node) == 1}
-    for w in W:
-        G.nodes[w]["value"] = G.degree[w] - 1
+    W = {node for node, deg in T.degree if deg == 1}
+    values.update({w: G.degree[w] - 1 for w in W})
 
     # step 3
     while T.number_of_nodes() >= 2:
         # step 4
-        w = min(W, key=lambda n: G.nodes[n]["value"])
-        try:
-            v = next(T.neighbors(w))
-        except StopIteration:
-            print(f"Vertex {v} has no adjacent vertices.")
+        w = min(W, key=lambda n: values[n])
+        v = next(T.neighbors(w))
 
         # step 5
         U.add(w)
@@ -89,10 +84,10 @@ def tree_broadcast(G):
         # step 6
         if T.degree(v) == 1:
             # update t(v)
-            G.nodes[v]["value"] = update_broadcast_label(G, U, v)
+            values.update({v: _get_max_broadcast_value(G, U, v, values)})
             W.add(v)
 
     # step 7
     v = list(T.nodes())[0]
-    b_T = update_broadcast_label(G, U, v)
+    b_T = _get_max_broadcast_value(G, U, v, values)
     return b_T
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index 40e4d2956c2..a541cffbc6c 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -34,16 +34,14 @@ def test_example_tree_broadcast():
         (18, 20),
     ]
     G.add_edges_from(edge_list)
-    b_G = nx_app.tree_broadcast(G)
-    assert b_G == 6
+    assert nx_app.tree_broadcast_time(G) == 6
 
 
 def test_path_broadcast():
     for i in range(2, 12):
         G = nx.path_graph(i)
-        assert nx_app.tree_broadcast(G) == math.ceil(i / 2)
+        assert nx_app.tree_broadcast_time(G) == math.ceil(i / 2)
 
     # test base case when the graph has only one node
-    H = nx.Graph()
-    H.add_node(0)
-    assert nx_app.tree_broadcast(H) == 0
+    H = nx.empty_graph(1)
+    assert nx_app.tree_broadcast_time(H) == 0

From adf2ea953f76994bceeb0038d7eea8d252dd8166 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Wed, 27 Sep 2023 15:46:37 -0400
Subject: [PATCH 107/129] updating docstrings for tree broadcast

---
 .../algorithms/approximation/broadcasting.py    | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index f668f2f9386..29c3a165144 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -15,20 +15,27 @@ def _get_max_broadcast_value(G, U, v, values):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 def tree_broadcast_time(G):
-    """
-    This functions implements a linear algorithm for determining the minimum broadcast time
-    on any tree [1]_. As a byproduct, it can also find a vertex which acts as the broadcast center,
-    i.e., the vertex where the broadcast begins.
+    """Return the optimal Broadcast Time of the tree G.
+
+    Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
+    must distribute a message to all other vertices by placing a series of calls along the edges of the graph.
+    Once informed, other vertices aid the originator in distributing the message. This is assumed to take place
+    in discrete time units.
+    The optimal broadcast time of a tree is defined as the minimum amount of time required to complete
+    broadcasting starting from the originator.
+    This function implements a linear algorithm for determining the minimum broadcast
+    time on any undirected tree [1]_.
 
     Parameters
     ----------
     G : NetworkX graph
         Undirected graph
+        The graph should be an undirected tree
 
     Returns
     -------
     b_T : int
-        Optimal Broadcast time of a tree
+        Optimal Broadcast Time of a tree
 
     Raises
     ------

From 583370e3923f8c2f78c9f83970722f5ef5007ec1 Mon Sep 17 00:00:00 2001
From: William Zijie Zhang <89562186+Transurgeon@users.noreply.github.com>
Date: Thu, 5 Oct 2023 12:04:15 -0400
Subject: [PATCH 108/129] Apply suggestions from code review

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/approximation/broadcasting.py            | 5 ++---
 networkx/algorithms/approximation/tests/test_broadcasting.py | 4 +---
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 29c3a165144..5d7ad5c55aa 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -74,8 +74,7 @@ def tree_broadcast_time(G):
     T.remove_nodes_from(U)
 
     # step 2
-    W = {node for node, deg in T.degree if deg == 1}
-    values.update({w: G.degree[w] - 1 for w in W})
+    values.update((node, deg -1) for node, deg in T.degree if deg = 1)
 
     # step 3
     while T.number_of_nodes() >= 2:
@@ -95,6 +94,6 @@ def tree_broadcast_time(G):
             W.add(v)
 
     # step 7
-    v = list(T.nodes())[0]
+    v = nx.utils.arbitrary_element(T)
     b_T = _get_max_broadcast_value(G, U, v, values)
     return b_T
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index a541cffbc6c..5b11b1c9a21 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -9,8 +9,6 @@ def test_example_tree_broadcast():
     """
     Test the BROADCAST algorithm on the example in the paper titled: "Information Dissemination in Trees"
     """
-    G = nx.Graph()
-    G.add_nodes_from(range(21))
     edge_list = [
         (0, 1),
         (1, 2),
@@ -33,7 +31,7 @@ def test_example_tree_broadcast():
         (18, 19),
         (18, 20),
     ]
-    G.add_edges_from(edge_list)
+    G = nx.Graph(edge_list)
     assert nx_app.tree_broadcast_time(G) == 6
 
 

From 3d3a7d530d5a8931fa5e52ea8c7b320efc0ac379 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Thu, 5 Oct 2023 16:07:58 -0400
Subject: [PATCH 109/129] removing self-loop check

---
 .../algorithms/approximation/broadcasting.py     | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 5d7ad5c55aa..ac6faee629c 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -47,18 +47,7 @@ def tree_broadcast_time(G):
     .. [1] Slater, P.J., Cockayne, E.J., Hedetniemi, S.T,
        Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
     """
-    # Remove selfloops if necessary
-    loop_nodes = nx.nodes_with_selfloops(G)
-    try:
-        node = next(loop_nodes)
-    except StopIteration:
-        pass
-    else:
-        G = G.copy()
-        G.remove_edge(node, node)
-        G.remove_edges_from((n, n) for n in loop_nodes)
-
-    # Assert that the graph G has no cycles
+    # Assert that the graph G is a tree
     if not nx.is_tree(G):
         NetworkXError("Your graph is not a tree")
     # step 0
@@ -74,7 +63,8 @@ def tree_broadcast_time(G):
     T.remove_nodes_from(U)
 
     # step 2
-    values.update((node, deg -1) for node, deg in T.degree if deg = 1)
+    W = {node for node, deg in T.degree if deg == 1}
+    values.update({w: G.degree[w] - 1 for w in W})
 
     # step 3
     while T.number_of_nodes() >= 2:

From 8d4458218894b090c0b4679605c168d58aa388ab Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Thu, 5 Oct 2023 17:30:01 -0400
Subject: [PATCH 110/129] cleaning update to avoid dict instance

---
 networkx/algorithms/approximation/broadcasting.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index ac6faee629c..4418d6be08b 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -64,7 +64,7 @@ def tree_broadcast_time(G):
 
     # step 2
     W = {node for node, deg in T.degree if deg == 1}
-    values.update({w: G.degree[w] - 1 for w in W})
+    values.update((w, G.degree[w] - 1) for w in W)
 
     # step 3
     while T.number_of_nodes() >= 2:

From a8a3756bbd6d41fda0ccd6da5a6a3dce6f1dfdff Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Thu, 5 Oct 2023 17:49:22 -0400
Subject: [PATCH 111/129] adding test case for star graph

---
 .../algorithms/approximation/tests/test_broadcasting.py     | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index 5b11b1c9a21..bb70aea79e2 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -43,3 +43,9 @@ def test_path_broadcast():
     # test base case when the graph has only one node
     H = nx.empty_graph(1)
     assert nx_app.tree_broadcast_time(H) == 0
+
+
+def test_star_broadcast():
+    for i in range(4, 12):
+        G = nx.star_graph(i)
+        assert nx_app.tree_broadcast_time(G) == i

From 74ea7afdf74ecd686129c47be641759a283e6f1c Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Thu, 5 Oct 2023 17:55:28 -0400
Subject: [PATCH 112/129] updating docstrings for constraints

---
 networkx/algorithms/approximation/broadcasting.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 4418d6be08b..4557836ddf0 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -15,13 +15,16 @@ def _get_max_broadcast_value(G, U, v, values):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 def tree_broadcast_time(G):
-    """Return the optimal Broadcast Time of the tree G.
+    """Return the minimum Broadcast Time of the tree G.
 
     Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
     must distribute a message to all other vertices by placing a series of calls along the edges of the graph.
-    Once informed, other vertices aid the originator in distributing the message. This is assumed to take place
-    in discrete time units.
-    The optimal broadcast time of a tree is defined as the minimum amount of time required to complete
+    Once informed, other vertices aid the originator in distributing the message.
+    The broadcasting must be completed as quickly as possible subject to the following constraints:
+    - Each call requires one unit of time.
+    - A vertex can only participate in one call per unit of time.
+    - Each call only involves two adjacent vertices: a sender and a receiver.
+    The minimum broadcast time of a tree is defined as the minimum amount of time required to complete
     broadcasting starting from the originator.
     This function implements a linear algorithm for determining the minimum broadcast
     time on any undirected tree [1]_.
@@ -35,7 +38,7 @@ def tree_broadcast_time(G):
     Returns
     -------
     b_T : int
-        Optimal Broadcast Time of a tree
+        Minimum Broadcast Time of a tree
 
     Raises
     ------

From 1f7df9540bcef9abb4b3c07b19df855f7ad42ab8 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Wed, 11 Oct 2023 22:09:27 -0400
Subject: [PATCH 113/129] applying some theoretical changes

---
 .../algorithms/approximation/broadcasting.py  | 65 ++++++++++++++-----
 .../approximation/tests/test_broadcasting.py  |  8 +--
 2 files changed, 53 insertions(+), 20 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 4557836ddf0..e1b8ac46f24 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -3,6 +3,7 @@
 from networkx.utils import not_implemented_for
 
 __all__ = [
+    "tree_broadcast_center",
     "tree_broadcast_time",
 ]
 
@@ -14,20 +15,11 @@ def _get_max_broadcast_value(G, U, v, values):
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-def tree_broadcast_time(G):
-    """Return the minimum Broadcast Time of the tree G.
+def tree_broadcast_center(G):
+    """Return the Broadcast Center of the tree G.
 
-    Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
-    must distribute a message to all other vertices by placing a series of calls along the edges of the graph.
-    Once informed, other vertices aid the originator in distributing the message.
-    The broadcasting must be completed as quickly as possible subject to the following constraints:
-    - Each call requires one unit of time.
-    - A vertex can only participate in one call per unit of time.
-    - Each call only involves two adjacent vertices: a sender and a receiver.
-    The minimum broadcast time of a tree is defined as the minimum amount of time required to complete
-    broadcasting starting from the originator.
-    This function implements a linear algorithm for determining the minimum broadcast
-    time on any undirected tree [1]_.
+    The broadcast number of a vertex v in a graph G is the minimum number of time units required to broadcast from v.
+    The broadcast center of a graph G is one of the vertices having minimum broadcast number.
 
     Parameters
     ----------
@@ -37,8 +29,8 @@ def tree_broadcast_time(G):
 
     Returns
     -------
-    b_T : int
-        Minimum Broadcast Time of a tree
+    BC : (int, int) tuple
+        Broadcast time from broadcast center, index of broadcast center of a tree
 
     Raises
     ------
@@ -89,4 +81,45 @@ def tree_broadcast_time(G):
     # step 7
     v = nx.utils.arbitrary_element(T)
     b_T = _get_max_broadcast_value(G, U, v, values)
-    return b_T
+    return b_T, v
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def tree_broadcast_time(G):
+    """Return the Broadcast Time of the tree G.
+
+    Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
+    must distribute a message to all other vertices by placing a series of calls along the edges of the graph.
+    Once informed, other vertices aid the originator in distributing the message.
+    The broadcasting must be completed as quickly as possible subject to the following constraints:
+    - Each call requires one unit of time.
+    - A vertex can only participate in one call per unit of time.
+    - Each call only involves two adjacent vertices: a sender and a receiver.
+    The minimum broadcast time of a vertex is defined as the minimum amount of time required to complete
+    broadcasting starting from the originator.
+    The broadcast time of a graph is defined as the maximum broadcast time from all its vertices.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+        The graph should be an undirected tree
+
+    Returns
+    -------
+    BT : int
+        Broadcast Time of a tree
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    References
+    ----------
+    .. [1] Slater, P.J., Cockayne, E.J., Hedetniemi, S.T,
+       Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
+    """
+    b_T, b_C = tree_broadcast_center(G)
+    return b_T + max(nx.eccentricity(G, b_C).values())
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index bb70aea79e2..363310c2b92 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -32,20 +32,20 @@ def test_example_tree_broadcast():
         (18, 20),
     ]
     G = nx.Graph(edge_list)
-    assert nx_app.tree_broadcast_time(G) == 6
+    assert nx_app.tree_broadcast_center(G) == 6
 
 
 def test_path_broadcast():
     for i in range(2, 12):
         G = nx.path_graph(i)
-        assert nx_app.tree_broadcast_time(G) == math.ceil(i / 2)
+        assert nx_app.tree_broadcast_center(G) == math.ceil(i / 2)
 
     # test base case when the graph has only one node
     H = nx.empty_graph(1)
-    assert nx_app.tree_broadcast_time(H) == 0
+    assert nx_app.tree_broadcast_center(H) == 0
 
 
 def test_star_broadcast():
     for i in range(4, 12):
         G = nx.star_graph(i)
-        assert nx_app.tree_broadcast_time(G) == i
+        assert nx_app.tree_broadcast_center(G) == i

From 27e4fce11ed1abfa68313cea5728e2f5d5867f0f Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Mon, 30 Oct 2023 17:08:59 -0400
Subject: [PATCH 114/129] adding broadcast center implementation and tests

---
 .../algorithms/approximation/broadcasting.py  | 33 ++++++++++++++-----
 .../approximation/tests/test_broadcasting.py  | 24 +++++++++++---
 2 files changed, 43 insertions(+), 14 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index e1b8ac46f24..30c5961fc0a 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -13,11 +13,19 @@ def _get_max_broadcast_value(G, U, v, values):
     return max(values[u] + i for i, u in enumerate(adj, start=1))
 
 
+def _get_broadcast_centers(G, v, values, target):
+    adj = sorted(set(G.neighbors(v)), key=lambda u: values[u], reverse=True)
+    j = min(i for i, u in enumerate(adj, start=1) if values[u] + i == target)
+    return set([v] + adj[:j])
+
+
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 def tree_broadcast_center(G):
     """Return the Broadcast Center of the tree G.
 
+    This is a linear algorithm for determining the broadcast center of any tree with N vertices,
+    as a by-product it can also determine the broadcast number of any vertex in the tree.
     The broadcast number of a vertex v in a graph G is the minimum number of time units required to broadcast from v.
     The broadcast center of a graph G is one of the vertices having minimum broadcast number.
 
@@ -29,8 +37,8 @@ def tree_broadcast_center(G):
 
     Returns
     -------
-    BC : (int, int) tuple
-        Broadcast time from broadcast center, index of broadcast center of a tree
+    BC : (int, set) tuple
+        minimum broadcast number of the tree, set of broadcast centers
 
     Raises
     ------
@@ -47,9 +55,9 @@ def tree_broadcast_center(G):
         NetworkXError("Your graph is not a tree")
     # step 0
     if G.number_of_nodes() == 2:
-        return 1
+        return 1, set(G.nodes())
     elif G.number_of_nodes() == 1:
-        return 0
+        return 0, set(G.nodes())
 
     # step 1
     U = {node for node, deg in G.degree if deg == 1}
@@ -81,12 +89,12 @@ def tree_broadcast_center(G):
     # step 7
     v = nx.utils.arbitrary_element(T)
     b_T = _get_max_broadcast_value(G, U, v, values)
-    return b_T, v
+    return b_T, _get_broadcast_centers(G, v, values, b_T)
 
 
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
-def tree_broadcast_time(G):
+def tree_broadcast_time(G, node=None):
     """Return the Broadcast Time of the tree G.
 
     Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
@@ -105,11 +113,14 @@ def tree_broadcast_time(G):
     G : NetworkX graph
         Undirected graph
         The graph should be an undirected tree
-
+    node: int
+        index of starting vertex. If none,
+        the algorithm returns the broadcast
+        time of the tree.
     Returns
     -------
     BT : int
-        Broadcast Time of a tree
+        Broadcast Time of a vertex in a tree
 
     Raises
     ------
@@ -122,4 +133,8 @@ def tree_broadcast_time(G):
        Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
     """
     b_T, b_C = tree_broadcast_center(G)
-    return b_T + max(nx.eccentricity(G, b_C).values())
+    if node is None:
+        return b_T + max(nx.eccentricity(G, b_C).values())
+    else:
+        b_T, b_C = tree_broadcast_center(G)
+        return b_T + max(nx.eccentricity(G, b_C).values())
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index 363310c2b92..ec56dc5cf57 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -32,20 +32,34 @@ def test_example_tree_broadcast():
         (18, 20),
     ]
     G = nx.Graph(edge_list)
-    assert nx_app.tree_broadcast_center(G) == 6
+    b_T, b_C = nx_app.tree_broadcast_center(G)
+    assert b_T == 6
+    assert b_C == {13, 9}
 
 
 def test_path_broadcast():
     for i in range(2, 12):
         G = nx.path_graph(i)
-        assert nx_app.tree_broadcast_center(G) == math.ceil(i / 2)
+        b_T, b_C = nx_app.tree_broadcast_center(G)
+        assert b_T == math.ceil(i / 2)
+        assert b_C == {
+            math.ceil(i / 2),
+            math.floor(i / 2),
+            math.ceil(i / 2 - 1),
+            math.floor(i / 2 - 1),
+        }
 
-    # test base case when the graph has only one node
+
+def test_empty_graph_broadcast():
     H = nx.empty_graph(1)
-    assert nx_app.tree_broadcast_center(H) == 0
+    b_T, b_C = nx_app.tree_broadcast_center(H)
+    assert b_T == 0
+    assert b_C == {0}
 
 
 def test_star_broadcast():
     for i in range(4, 12):
         G = nx.star_graph(i)
-        assert nx_app.tree_broadcast_center(G) == i
+        b_T, b_C = nx_app.tree_broadcast_center(G)
+        assert b_T == i
+        assert b_C == set(G.nodes())

From e130a464dfe79925b8da787858735c62da20bd42 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Mon, 30 Oct 2023 20:35:09 -0400
Subject: [PATCH 115/129] completing tree broadcast algorithm and tests

---
 .../algorithms/approximation/broadcasting.py    |  7 +++----
 .../approximation/tests/test_broadcasting.py    | 17 +++++++++++++++++
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 30c5961fc0a..e46635483d6 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -133,8 +133,7 @@ def tree_broadcast_time(G, node=None):
        Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
     """
     b_T, b_C = tree_broadcast_center(G)
-    if node is None:
-        return b_T + max(nx.eccentricity(G, b_C).values())
+    if node is not None:
+        return b_T + min(nx.shortest_path_length(G, node, u) for u in b_C)
     else:
-        b_T, b_C = tree_broadcast_center(G)
-        return b_T + max(nx.eccentricity(G, b_C).values())
+        return b_T + max(min(nx.shortest_path_length(G, v, u) for u in b_C) for v in G)
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
index ec56dc5cf57..88ba7931f09 100644
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ b/networkx/algorithms/approximation/tests/test_broadcasting.py
@@ -35,6 +35,11 @@ def test_example_tree_broadcast():
     b_T, b_C = nx_app.tree_broadcast_center(G)
     assert b_T == 6
     assert b_C == {13, 9}
+    # test broadcast time from specific vertex
+    assert nx_app.tree_broadcast_time(G, 17) == 8
+    assert nx_app.tree_broadcast_time(G, 3) == 9
+    # test broadcast time of entire tree
+    assert nx_app.tree_broadcast_time(G) == 10
 
 
 def test_path_broadcast():
@@ -48,6 +53,7 @@ def test_path_broadcast():
             math.ceil(i / 2 - 1),
             math.floor(i / 2 - 1),
         }
+        assert nx_app.tree_broadcast_time(G) == i - 1
 
 
 def test_empty_graph_broadcast():
@@ -55,6 +61,7 @@ def test_empty_graph_broadcast():
     b_T, b_C = nx_app.tree_broadcast_center(H)
     assert b_T == 0
     assert b_C == {0}
+    assert nx_app.tree_broadcast_time(H) == 0
 
 
 def test_star_broadcast():
@@ -63,3 +70,13 @@ def test_star_broadcast():
         b_T, b_C = nx_app.tree_broadcast_center(G)
         assert b_T == i
         assert b_C == set(G.nodes())
+        assert nx_app.tree_broadcast_time(G) == b_T
+
+
+def test_binomial_tree_broadcast():
+    for i in range(2, 8):
+        G = nx.binomial_tree(i)
+        b_T, b_C = nx_app.tree_broadcast_center(G)
+        assert b_T == i
+        assert b_C == {0, 2 ** (i - 1)}
+        assert nx_app.tree_broadcast_time(G) == 2 * i - 1

From 48d1d246aa7cd456679b7b687038a36566de44f9 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Thu, 30 Nov 2023 22:28:59 -0500
Subject: [PATCH 116/129] adding first set of changes round 2

---
 networkx/algorithms/approximation/broadcasting.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index e46635483d6..2a33966d651 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -9,13 +9,13 @@
 
 
 def _get_max_broadcast_value(G, U, v, values):
-    adj = sorted(set(G.neighbors(v)) & U, key=lambda u: values[u], reverse=True)
+    adj = sorted(set(G.neighbors(v)) & U, key=values.get, reverse=True)
     return max(values[u] + i for i, u in enumerate(adj, start=1))
 
 
 def _get_broadcast_centers(G, v, values, target):
-    adj = sorted(set(G.neighbors(v)), key=lambda u: values[u], reverse=True)
-    j = min(i for i, u in enumerate(adj, start=1) if values[u] + i == target)
+    adj = sorted(G.neighbors(v), key=values.get, reverse=True)
+    j = next(i for i, u in enumerate(adj, start=1) if values[u] + i == target)
     return set([v] + adj[:j])
 
 
@@ -25,9 +25,9 @@ def tree_broadcast_center(G):
     """Return the Broadcast Center of the tree G.
 
     This is a linear algorithm for determining the broadcast center of any tree with N vertices,
-    as a by-product it can also determine the broadcast number of any vertex in the tree.
-    The broadcast number of a vertex v in a graph G is the minimum number of time units required to broadcast from v.
-    The broadcast center of a graph G is one of the vertices having minimum broadcast number.
+    as a by-product it can also determine the broadcast time of any vertex in the tree.
+    The broadcast time of a vertex v in a graph G is the minimum number of time units required to broadcast from v.
+    The broadcast center of a graph G is one of the vertices having minimum broadcast time.
 
     Parameters
     ----------

From 531649df4b99c5fdda9d7cd69cab67117c391270 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Sun, 10 Dec 2023 15:53:29 -0500
Subject: [PATCH 117/129] adding optimization for broadcast time of the tree

---
 .../algorithms/approximation/broadcasting.py  | 21 ++++++++++++-------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 2a33966d651..18fd19436e8 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -24,10 +24,9 @@ def _get_broadcast_centers(G, v, values, target):
 def tree_broadcast_center(G):
     """Return the Broadcast Center of the tree G.
 
-    This is a linear algorithm for determining the broadcast center of any tree with N vertices,
-    as a by-product it can also determine the broadcast time of any vertex in the tree.
-    The broadcast time of a vertex v in a graph G is the minimum number of time units required to broadcast from v.
-    The broadcast center of a graph G is one of the vertices having minimum broadcast time.
+    The broadcast center of a graph G denotes the set of vertices having minimum broadcast time [1]_.
+    This is a linear algorithm for determining the broadcast center of a tree with N vertices,
+    as a by-product it can also determine the broadcast time from the broadcast center.
 
     Parameters
     ----------
@@ -106,7 +105,7 @@ def tree_broadcast_time(G, node=None):
     - Each call only involves two adjacent vertices: a sender and a receiver.
     The minimum broadcast time of a vertex is defined as the minimum amount of time required to complete
     broadcasting starting from the originator.
-    The broadcast time of a graph is defined as the maximum broadcast time from all its vertices.
+    The broadcast time of a graph is the maximum time required to broadcast from any vertex in the graph [1]_.
 
     Parameters
     ----------
@@ -129,11 +128,17 @@ def tree_broadcast_time(G, node=None):
 
     References
     ----------
-    .. [1] Slater, P.J., Cockayne, E.J., Hedetniemi, S.T,
-       Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
+    .. [1] Harutyunyan, H. A. and Li, Z. "A Simple Construction of Broadcast Graphs."
+    In Computing and Combinatorics. COCOON 2019 (Ed. D. Z. Du and C. Tian.) Cham,
+    Switzerland: Springer, pp. 240-253, 2019.
     """
     b_T, b_C = tree_broadcast_center(G)
     if node is not None:
         return b_T + min(nx.shortest_path_length(G, node, u) for u in b_C)
     else:
-        return b_T + max(min(nx.shortest_path_length(G, v, u) for u in b_C) for v in G)
+        dist_from_center = dict.fromkeys(G, len(G))
+        for u in b_C:
+            for v, dist in nx.shortest_path_length(G, u).items():
+                if dist < dist_from_center[v]:
+                    dist_from_center[v] = dist
+        return b_T + max(dist_from_center.values())

From 603888a1cc7bdb36033b75852e5bfde538910048 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Tue, 16 Jan 2024 22:16:06 -0500
Subject: [PATCH 118/129] copying code to new location

---
 doc/reference/algorithms/broadcasting.rst     |  10 ++
 networkx/algorithms/__init__.py               |   1 +
 networkx/algorithms/approximation/__init__.py |   1 -
 networkx/algorithms/broadcasting.py           | 155 ++++++++++++++++++
 .../algorithms/tests/test_broadcasting.py     |  81 +++++++++
 5 files changed, 247 insertions(+), 1 deletion(-)
 create mode 100644 doc/reference/algorithms/broadcasting.rst
 create mode 100644 networkx/algorithms/broadcasting.py
 create mode 100644 networkx/algorithms/tests/test_broadcasting.py

diff --git a/doc/reference/algorithms/broadcasting.rst b/doc/reference/algorithms/broadcasting.rst
new file mode 100644
index 00000000000..3c2164982ff
--- /dev/null
+++ b/doc/reference/algorithms/broadcasting.rst
@@ -0,0 +1,10 @@
+************
+Broadcasting
+************
+
+.. automodule:: networkx.algorithms.broadcasting
+.. autosummary::
+   :toctree: generated/
+
+   tree_broadcast_center
+   tree_broadcast_time
diff --git a/networkx/algorithms/__init__.py b/networkx/algorithms/__init__.py
index eda2912cadd..56bfb14afdf 100644
--- a/networkx/algorithms/__init__.py
+++ b/networkx/algorithms/__init__.py
@@ -1,6 +1,7 @@
 from networkx.algorithms.assortativity import *
 from networkx.algorithms.asteroidal import *
 from networkx.algorithms.boundary import *
+from networkx.algorithms.broadcasting import *
 from networkx.algorithms.bridges import *
 from networkx.algorithms.chains import *
 from networkx.algorithms.centrality import *
diff --git a/networkx/algorithms/approximation/__init__.py b/networkx/algorithms/approximation/__init__.py
index 0e328a9ef36..e39dc00aa25 100644
--- a/networkx/algorithms/approximation/__init__.py
+++ b/networkx/algorithms/approximation/__init__.py
@@ -9,7 +9,6 @@
 ``from networkx.algorithms.approximation import function_name``.
 
 """
-from networkx.algorithms.approximation.broadcasting import *
 from networkx.algorithms.approximation.clustering_coefficient import *
 from networkx.algorithms.approximation.clique import *
 from networkx.algorithms.approximation.connectivity import *
diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
new file mode 100644
index 00000000000..cdda308737d
--- /dev/null
+++ b/networkx/algorithms/broadcasting.py
@@ -0,0 +1,155 @@
+"""Routines to find the boundary of a set of nodes.
+
+An edge boundary is a set of edges, each of which has exactly one
+endpoint in a given set of nodes (or, in the case of directed graphs,
+the set of edges whose source node is in the set).
+
+A node boundary of a set *S* of nodes is the set of (out-)neighbors of
+nodes in *S* that are outside *S*.
+
+"""
+
+import networkx as nx
+from networkx import NetworkXError
+from networkx.utils import not_implemented_for
+
+__all__ = [
+    "tree_broadcast_center",
+    "tree_broadcast_time",
+]
+
+
+def _get_max_broadcast_value(G, U, v, values):
+    adj = sorted(set(G.neighbors(v)) & U, key=values.get, reverse=True)
+    return max(values[u] + i for i, u in enumerate(adj, start=1))
+
+
+def _get_broadcast_centers(G, v, values, target):
+    adj = sorted(G.neighbors(v), key=values.get, reverse=True)
+    j = next(i for i, u in enumerate(adj, start=1) if values[u] + i == target)
+    return set([v] + adj[:j])
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def tree_broadcast_center(G):
+    """Return the Broadcast Center of the tree G.
+
+    The broadcast center of a graph G denotes the set of vertices having minimum broadcast time [1]_.
+    This is a linear algorithm for determining the broadcast center of a tree with N vertices,
+    as a by-product it can also determine the broadcast time from the broadcast center.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+        The graph should be an undirected tree
+
+    Returns
+    -------
+    BC : (int, set) tuple
+        minimum broadcast number of the tree, set of broadcast centers
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    References
+    ----------
+    .. [1] Slater, P.J., Cockayne, E.J., Hedetniemi, S.T,
+       Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
+    """
+    # Assert that the graph G is a tree
+    if not nx.is_tree(G):
+        NetworkXError("Your graph is not a tree")
+    # step 0
+    if G.number_of_nodes() == 2:
+        return 1, set(G.nodes())
+    elif G.number_of_nodes() == 1:
+        return 0, set(G.nodes())
+
+    # step 1
+    U = {node for node, deg in G.degree if deg == 1}
+    values = {n: 0 for n in U}
+    T = G.copy()
+    T.remove_nodes_from(U)
+
+    # step 2
+    W = {node for node, deg in T.degree if deg == 1}
+    values.update((w, G.degree[w] - 1) for w in W)
+
+    # step 3
+    while T.number_of_nodes() >= 2:
+        # step 4
+        w = min(W, key=lambda n: values[n])
+        v = next(T.neighbors(w))
+
+        # step 5
+        U.add(w)
+        W.remove(w)
+        T.remove_node(w)
+
+        # step 6
+        if T.degree(v) == 1:
+            # update t(v)
+            values.update({v: _get_max_broadcast_value(G, U, v, values)})
+            W.add(v)
+
+    # step 7
+    v = nx.utils.arbitrary_element(T)
+    b_T = _get_max_broadcast_value(G, U, v, values)
+    return b_T, _get_broadcast_centers(G, v, values, b_T)
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+def tree_broadcast_time(G, node=None):
+    """Return the Broadcast Time of the tree G.
+
+    Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
+    must distribute a message to all other vertices by placing a series of calls along the edges of the graph.
+    Once informed, other vertices aid the originator in distributing the message.
+    The broadcasting must be completed as quickly as possible subject to the following constraints:
+    - Each call requires one unit of time.
+    - A vertex can only participate in one call per unit of time.
+    - Each call only involves two adjacent vertices: a sender and a receiver.
+    The minimum broadcast time of a vertex is defined as the minimum amount of time required to complete
+    broadcasting starting from the originator.
+    The broadcast time of a graph is the maximum time required to broadcast from any vertex in the graph [1]_.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        Undirected graph
+        The graph should be an undirected tree
+    node: int
+        index of starting vertex. If none,
+        the algorithm returns the broadcast
+        time of the tree.
+    Returns
+    -------
+    BT : int
+        Broadcast Time of a vertex in a tree
+
+    Raises
+    ------
+    NetworkXNotImplemented
+        If the graph is directed or is a multigraph.
+
+    References
+    ----------
+    .. [1] Harutyunyan, H. A. and Li, Z. "A Simple Construction of Broadcast Graphs."
+    In Computing and Combinatorics. COCOON 2019 (Ed. D. Z. Du and C. Tian.) Cham,
+    Switzerland: Springer, pp. 240-253, 2019.
+    """
+    b_T, b_C = tree_broadcast_center(G)
+    if node is not None:
+        return b_T + min(nx.shortest_path_length(G, node, u) for u in b_C)
+    else:
+        dist_from_center = dict.fromkeys(G, len(G))
+        for u in b_C:
+            for v, dist in nx.shortest_path_length(G, u).items():
+                if dist < dist_from_center[v]:
+                    dist_from_center[v] = dist
+        return b_T + max(dist_from_center.values())
diff --git a/networkx/algorithms/tests/test_broadcasting.py b/networkx/algorithms/tests/test_broadcasting.py
new file mode 100644
index 00000000000..8ce34cf2bcc
--- /dev/null
+++ b/networkx/algorithms/tests/test_broadcasting.py
@@ -0,0 +1,81 @@
+"""Unit tests for the broadcasting module."""
+import math
+
+import networkx as nx
+
+
+def test_example_tree_broadcast():
+    """
+    Test the BROADCAST algorithm on the example in the paper titled: "Information Dissemination in Trees"
+    """
+    edge_list = [
+        (0, 1),
+        (1, 2),
+        (2, 7),
+        (3, 4),
+        (5, 4),
+        (4, 7),
+        (6, 7),
+        (7, 9),
+        (8, 9),
+        (9, 13),
+        (13, 14),
+        (14, 15),
+        (14, 16),
+        (14, 17),
+        (13, 11),
+        (11, 10),
+        (11, 12),
+        (13, 18),
+        (18, 19),
+        (18, 20),
+    ]
+    G = nx.Graph(edge_list)
+    b_T, b_C = nx.tree_broadcast_center(G)
+    assert b_T == 6
+    assert b_C == {13, 9}
+    # test broadcast time from specific vertex
+    assert nx.tree_broadcast_time(G, 17) == 8
+    assert nx.tree_broadcast_time(G, 3) == 9
+    # test broadcast time of entire tree
+    assert nx.tree_broadcast_time(G) == 10
+
+
+def test_path_broadcast():
+    for i in range(2, 12):
+        G = nx.path_graph(i)
+        b_T, b_C = nx.tree_broadcast_center(G)
+        assert b_T == math.ceil(i / 2)
+        assert b_C == {
+            math.ceil(i / 2),
+            math.floor(i / 2),
+            math.ceil(i / 2 - 1),
+            math.floor(i / 2 - 1),
+        }
+        assert nx.tree_broadcast_time(G) == i - 1
+
+
+def test_empty_graph_broadcast():
+    H = nx.empty_graph(1)
+    b_T, b_C = nx.tree_broadcast_center(H)
+    assert b_T == 0
+    assert b_C == {0}
+    assert nx.tree_broadcast_time(H) == 0
+
+
+def test_star_broadcast():
+    for i in range(4, 12):
+        G = nx.star_graph(i)
+        b_T, b_C = nx.tree_broadcast_center(G)
+        assert b_T == i
+        assert b_C == set(G.nodes())
+        assert nx.tree_broadcast_time(G) == b_T
+
+
+def test_binomial_tree_broadcast():
+    for i in range(2, 8):
+        G = nx.binomial_tree(i)
+        b_T, b_C = nx.tree_broadcast_center(G)
+        assert b_T == i
+        assert b_C == {0, 2 ** (i - 1)}
+        assert nx.tree_broadcast_time(G) == 2 * i - 1

From f4cdc9e9dd62cc7248e34117657e0bfa16dd5f44 Mon Sep 17 00:00:00 2001
From: William Zijie Zhang <89562186+Transurgeon@users.noreply.github.com>
Date: Tue, 16 Jan 2024 17:13:28 -0500
Subject: [PATCH 119/129] Update
 networkx/algorithms/approximation/broadcasting.py

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/approximation/broadcasting.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 18fd19436e8..07dfd3b372b 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -113,7 +113,7 @@ def tree_broadcast_time(G, node=None):
         Undirected graph
         The graph should be an undirected tree
     node: int
-        index of starting vertex. If none,
+        index of starting vertex. If None,
         the algorithm returns the broadcast
         time of the tree.
     Returns

From 7f05b51619b6ada9ba498302d54d189a1e7c72bb Mon Sep 17 00:00:00 2001
From: William Zijie Zhang <89562186+Transurgeon@users.noreply.github.com>
Date: Tue, 16 Jan 2024 17:13:56 -0500
Subject: [PATCH 120/129] Update
 networkx/algorithms/approximation/broadcasting.py

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/approximation/broadcasting.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
index 07dfd3b372b..281496c5140 100644
--- a/networkx/algorithms/approximation/broadcasting.py
+++ b/networkx/algorithms/approximation/broadcasting.py
@@ -105,7 +105,8 @@ def tree_broadcast_time(G, node=None):
     - Each call only involves two adjacent vertices: a sender and a receiver.
     The minimum broadcast time of a vertex is defined as the minimum amount of time required to complete
     broadcasting starting from the originator.
-    The broadcast time of a graph is the maximum time required to broadcast from any vertex in the graph [1]_.
+    The broadcast time of a graph is the maximum over all nodes of the
+    minimum broadcast time from that node [1]_.
 
     Parameters
     ----------

From 0d75863fc3ef009e189bf423122fbdc83fdda79f Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Tue, 16 Jan 2024 22:19:50 -0500
Subject: [PATCH 121/129] changing all instances of vertices to nodes

---
 networkx/algorithms/broadcasting.py | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
index cdda308737d..b949bbb6dcc 100644
--- a/networkx/algorithms/broadcasting.py
+++ b/networkx/algorithms/broadcasting.py
@@ -35,8 +35,8 @@ def _get_broadcast_centers(G, v, values, target):
 def tree_broadcast_center(G):
     """Return the Broadcast Center of the tree G.
 
-    The broadcast center of a graph G denotes the set of vertices having minimum broadcast time [1]_.
-    This is a linear algorithm for determining the broadcast center of a tree with N vertices,
+    The broadcast center of a graph G denotes the set of nodes having minimum broadcast time [1]_.
+    This is a linear algorithm for determining the broadcast center of a tree with N nodes,
     as a by-product it can also determine the broadcast time from the broadcast center.
 
     Parameters
@@ -107,16 +107,16 @@ def tree_broadcast_center(G):
 def tree_broadcast_time(G, node=None):
     """Return the Broadcast Time of the tree G.
 
-    Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
-    must distribute a message to all other vertices by placing a series of calls along the edges of the graph.
-    Once informed, other vertices aid the originator in distributing the message.
+    Broadcasting is an information dissemination problem in which a node in a graph, called the originator,
+    must distribute a message to all other nodes by placing a series of calls along the edges of the graph.
+    Once informed, other nodes aid the originator in distributing the message.
     The broadcasting must be completed as quickly as possible subject to the following constraints:
     - Each call requires one unit of time.
-    - A vertex can only participate in one call per unit of time.
-    - Each call only involves two adjacent vertices: a sender and a receiver.
-    The minimum broadcast time of a vertex is defined as the minimum amount of time required to complete
+    - A node can only participate in one call per unit of time.
+    - Each call only involves two adjacent nodes: a sender and a receiver.
+    The minimum broadcast time of a node is defined as the minimum amount of time required to complete
     broadcasting starting from the originator.
-    The broadcast time of a graph is the maximum time required to broadcast from any vertex in the graph [1]_.
+    The broadcast time of a graph is the maximum time required to broadcast from any node in the graph [1]_.
 
     Parameters
     ----------
@@ -127,6 +127,7 @@ def tree_broadcast_time(G, node=None):
         index of starting vertex. If none,
         the algorithm returns the broadcast
         time of the tree.
+
     Returns
     -------
     BT : int

From dcf996976374fb2dd779e035275b88ccd5c4ab0a Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Tue, 16 Jan 2024 22:28:41 -0500
Subject: [PATCH 122/129] fixing up some formatting issues

---
 networkx/algorithms/broadcasting.py | 52 ++++++++++++++---------------
 1 file changed, 25 insertions(+), 27 deletions(-)

diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
index b949bbb6dcc..db1453519a5 100644
--- a/networkx/algorithms/broadcasting.py
+++ b/networkx/algorithms/broadcasting.py
@@ -1,12 +1,15 @@
-"""Routines to find the boundary of a set of nodes.
-
-An edge boundary is a set of edges, each of which has exactly one
-endpoint in a given set of nodes (or, in the case of directed graphs,
-the set of edges whose source node is in the set).
-
-A node boundary of a set *S* of nodes is the set of (out-)neighbors of
-nodes in *S* that are outside *S*.
-
+"""Routines to calculate the broadcast time of certain graphs.
+
+Broadcasting is an information dissemination problem in which a node in a graph,
+called the originator, must distribute a message to all other nodes by placing
+a series of calls along the edges of the graph. Once informed, other nodes aid
+the originator in distributing the message.
+
+The broadcasting must be completed as quickly as possible subject to the
+following constraints:
+- Each call requires one unit of time.
+- A node can only participate in one call per unit of time.
+- Each call only involves two adjacent nodes: a sender and a receiver.
 """
 
 import networkx as nx
@@ -35,9 +38,10 @@ def _get_broadcast_centers(G, v, values, target):
 def tree_broadcast_center(G):
     """Return the Broadcast Center of the tree G.
 
-    The broadcast center of a graph G denotes the set of nodes having minimum broadcast time [1]_.
-    This is a linear algorithm for determining the broadcast center of a tree with N nodes,
-    as a by-product it can also determine the broadcast time from the broadcast center.
+    The broadcast center of a graph G denotes the set of nodes having
+    minimum broadcast time [1]_. This is a linear algorithm for determining
+    the broadcast center of a tree with N nodes, as a by-product it can also
+    determine the broadcast time from the broadcast center.
 
     Parameters
     ----------
@@ -107,16 +111,10 @@ def tree_broadcast_center(G):
 def tree_broadcast_time(G, node=None):
     """Return the Broadcast Time of the tree G.
 
-    Broadcasting is an information dissemination problem in which a node in a graph, called the originator,
-    must distribute a message to all other nodes by placing a series of calls along the edges of the graph.
-    Once informed, other nodes aid the originator in distributing the message.
-    The broadcasting must be completed as quickly as possible subject to the following constraints:
-    - Each call requires one unit of time.
-    - A node can only participate in one call per unit of time.
-    - Each call only involves two adjacent nodes: a sender and a receiver.
-    The minimum broadcast time of a node is defined as the minimum amount of time required to complete
-    broadcasting starting from the originator.
-    The broadcast time of a graph is the maximum time required to broadcast from any node in the graph [1]_.
+    The minimum broadcast time of a node is defined as the minimum amount
+    of time required to complete broadcasting starting from the
+    originator. The broadcast time of a graph is the maximum over
+    all nodes of the minimum broadcast time from that node [1]_.
 
     Parameters
     ----------
@@ -124,14 +122,14 @@ def tree_broadcast_time(G, node=None):
         Undirected graph
         The graph should be an undirected tree
     node: int
-        index of starting vertex. If none,
+        index of starting node. If None,
         the algorithm returns the broadcast
         time of the tree.
 
     Returns
     -------
     BT : int
-        Broadcast Time of a vertex in a tree
+        Broadcast Time of a node in a tree
 
     Raises
     ------
@@ -140,9 +138,9 @@ def tree_broadcast_time(G, node=None):
 
     References
     ----------
-    .. [1] Harutyunyan, H. A. and Li, Z. "A Simple Construction of Broadcast Graphs."
-    In Computing and Combinatorics. COCOON 2019 (Ed. D. Z. Du and C. Tian.) Cham,
-    Switzerland: Springer, pp. 240-253, 2019.
+    .. [1] Harutyunyan, H. A. and Li, Z. "A Simple Construction of
+    Broadcast Graphs." In Computing and Combinatorics. COCOON 2019
+    (Ed. D. Z. Du and C. Tian.) Cham, Switzerland: Springer, pp. 240-253, 2019.
     """
     b_T, b_C = tree_broadcast_center(G)
     if node is not None:

From b401d093a561afff5ba4474e5cdae96315de3231 Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Tue, 16 Jan 2024 22:31:51 -0500
Subject: [PATCH 123/129] removing two previous files from implementation

---
 .../algorithms/approximation/broadcasting.py  | 145 ------------------
 .../approximation/tests/test_broadcasting.py  |  82 ----------
 2 files changed, 227 deletions(-)
 delete mode 100644 networkx/algorithms/approximation/broadcasting.py
 delete mode 100644 networkx/algorithms/approximation/tests/test_broadcasting.py

diff --git a/networkx/algorithms/approximation/broadcasting.py b/networkx/algorithms/approximation/broadcasting.py
deleted file mode 100644
index 281496c5140..00000000000
--- a/networkx/algorithms/approximation/broadcasting.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import networkx as nx
-from networkx import NetworkXError
-from networkx.utils import not_implemented_for
-
-__all__ = [
-    "tree_broadcast_center",
-    "tree_broadcast_time",
-]
-
-
-def _get_max_broadcast_value(G, U, v, values):
-    adj = sorted(set(G.neighbors(v)) & U, key=values.get, reverse=True)
-    return max(values[u] + i for i, u in enumerate(adj, start=1))
-
-
-def _get_broadcast_centers(G, v, values, target):
-    adj = sorted(G.neighbors(v), key=values.get, reverse=True)
-    j = next(i for i, u in enumerate(adj, start=1) if values[u] + i == target)
-    return set([v] + adj[:j])
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-def tree_broadcast_center(G):
-    """Return the Broadcast Center of the tree G.
-
-    The broadcast center of a graph G denotes the set of vertices having minimum broadcast time [1]_.
-    This is a linear algorithm for determining the broadcast center of a tree with N vertices,
-    as a by-product it can also determine the broadcast time from the broadcast center.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-        The graph should be an undirected tree
-
-    Returns
-    -------
-    BC : (int, set) tuple
-        minimum broadcast number of the tree, set of broadcast centers
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the graph is directed or is a multigraph.
-
-    References
-    ----------
-    .. [1] Slater, P.J., Cockayne, E.J., Hedetniemi, S.T,
-       Information dissemination in trees. SIAM J.Comput. 10(4), 692–701 (1981)
-    """
-    # Assert that the graph G is a tree
-    if not nx.is_tree(G):
-        NetworkXError("Your graph is not a tree")
-    # step 0
-    if G.number_of_nodes() == 2:
-        return 1, set(G.nodes())
-    elif G.number_of_nodes() == 1:
-        return 0, set(G.nodes())
-
-    # step 1
-    U = {node for node, deg in G.degree if deg == 1}
-    values = {n: 0 for n in U}
-    T = G.copy()
-    T.remove_nodes_from(U)
-
-    # step 2
-    W = {node for node, deg in T.degree if deg == 1}
-    values.update((w, G.degree[w] - 1) for w in W)
-
-    # step 3
-    while T.number_of_nodes() >= 2:
-        # step 4
-        w = min(W, key=lambda n: values[n])
-        v = next(T.neighbors(w))
-
-        # step 5
-        U.add(w)
-        W.remove(w)
-        T.remove_node(w)
-
-        # step 6
-        if T.degree(v) == 1:
-            # update t(v)
-            values.update({v: _get_max_broadcast_value(G, U, v, values)})
-            W.add(v)
-
-    # step 7
-    v = nx.utils.arbitrary_element(T)
-    b_T = _get_max_broadcast_value(G, U, v, values)
-    return b_T, _get_broadcast_centers(G, v, values, b_T)
-
-
-@not_implemented_for("directed")
-@not_implemented_for("multigraph")
-def tree_broadcast_time(G, node=None):
-    """Return the Broadcast Time of the tree G.
-
-    Broadcasting is an information dissemination problem in which one vertex in a graph, called the originator,
-    must distribute a message to all other vertices by placing a series of calls along the edges of the graph.
-    Once informed, other vertices aid the originator in distributing the message.
-    The broadcasting must be completed as quickly as possible subject to the following constraints:
-    - Each call requires one unit of time.
-    - A vertex can only participate in one call per unit of time.
-    - Each call only involves two adjacent vertices: a sender and a receiver.
-    The minimum broadcast time of a vertex is defined as the minimum amount of time required to complete
-    broadcasting starting from the originator.
-    The broadcast time of a graph is the maximum over all nodes of the
-    minimum broadcast time from that node [1]_.
-
-    Parameters
-    ----------
-    G : NetworkX graph
-        Undirected graph
-        The graph should be an undirected tree
-    node: int
-        index of starting vertex. If None,
-        the algorithm returns the broadcast
-        time of the tree.
-    Returns
-    -------
-    BT : int
-        Broadcast Time of a vertex in a tree
-
-    Raises
-    ------
-    NetworkXNotImplemented
-        If the graph is directed or is a multigraph.
-
-    References
-    ----------
-    .. [1] Harutyunyan, H. A. and Li, Z. "A Simple Construction of Broadcast Graphs."
-    In Computing and Combinatorics. COCOON 2019 (Ed. D. Z. Du and C. Tian.) Cham,
-    Switzerland: Springer, pp. 240-253, 2019.
-    """
-    b_T, b_C = tree_broadcast_center(G)
-    if node is not None:
-        return b_T + min(nx.shortest_path_length(G, node, u) for u in b_C)
-    else:
-        dist_from_center = dict.fromkeys(G, len(G))
-        for u in b_C:
-            for v, dist in nx.shortest_path_length(G, u).items():
-                if dist < dist_from_center[v]:
-                    dist_from_center[v] = dist
-        return b_T + max(dist_from_center.values())
diff --git a/networkx/algorithms/approximation/tests/test_broadcasting.py b/networkx/algorithms/approximation/tests/test_broadcasting.py
deleted file mode 100644
index 88ba7931f09..00000000000
--- a/networkx/algorithms/approximation/tests/test_broadcasting.py
+++ /dev/null
@@ -1,82 +0,0 @@
-"""Unit tests for the broadcasting module."""
-import math
-
-import networkx as nx
-import networkx.algorithms.approximation as nx_app
-
-
-def test_example_tree_broadcast():
-    """
-    Test the BROADCAST algorithm on the example in the paper titled: "Information Dissemination in Trees"
-    """
-    edge_list = [
-        (0, 1),
-        (1, 2),
-        (2, 7),
-        (3, 4),
-        (5, 4),
-        (4, 7),
-        (6, 7),
-        (7, 9),
-        (8, 9),
-        (9, 13),
-        (13, 14),
-        (14, 15),
-        (14, 16),
-        (14, 17),
-        (13, 11),
-        (11, 10),
-        (11, 12),
-        (13, 18),
-        (18, 19),
-        (18, 20),
-    ]
-    G = nx.Graph(edge_list)
-    b_T, b_C = nx_app.tree_broadcast_center(G)
-    assert b_T == 6
-    assert b_C == {13, 9}
-    # test broadcast time from specific vertex
-    assert nx_app.tree_broadcast_time(G, 17) == 8
-    assert nx_app.tree_broadcast_time(G, 3) == 9
-    # test broadcast time of entire tree
-    assert nx_app.tree_broadcast_time(G) == 10
-
-
-def test_path_broadcast():
-    for i in range(2, 12):
-        G = nx.path_graph(i)
-        b_T, b_C = nx_app.tree_broadcast_center(G)
-        assert b_T == math.ceil(i / 2)
-        assert b_C == {
-            math.ceil(i / 2),
-            math.floor(i / 2),
-            math.ceil(i / 2 - 1),
-            math.floor(i / 2 - 1),
-        }
-        assert nx_app.tree_broadcast_time(G) == i - 1
-
-
-def test_empty_graph_broadcast():
-    H = nx.empty_graph(1)
-    b_T, b_C = nx_app.tree_broadcast_center(H)
-    assert b_T == 0
-    assert b_C == {0}
-    assert nx_app.tree_broadcast_time(H) == 0
-
-
-def test_star_broadcast():
-    for i in range(4, 12):
-        G = nx.star_graph(i)
-        b_T, b_C = nx_app.tree_broadcast_center(G)
-        assert b_T == i
-        assert b_C == set(G.nodes())
-        assert nx_app.tree_broadcast_time(G) == b_T
-
-
-def test_binomial_tree_broadcast():
-    for i in range(2, 8):
-        G = nx.binomial_tree(i)
-        b_T, b_C = nx_app.tree_broadcast_center(G)
-        assert b_T == i
-        assert b_C == {0, 2 ** (i - 1)}
-        assert nx_app.tree_broadcast_time(G) == 2 * i - 1

From 0d866b1d1ec467d73d74097357327d93a0d38b8c Mon Sep 17 00:00:00 2001
From: Transurgeon <peter.zijie@gmail.com>
Date: Wed, 17 Jan 2024 14:11:16 -0500
Subject: [PATCH 124/129] adding broadcsting to index reference file

---
 doc/reference/algorithms/index.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/reference/algorithms/index.rst b/doc/reference/algorithms/index.rst
index f8c5aff485d..2dd8d8f054a 100644
--- a/doc/reference/algorithms/index.rst
+++ b/doc/reference/algorithms/index.rst
@@ -15,6 +15,7 @@ Algorithms
    bipartite
    boundary
    bridges
+   broadcasting
    centrality
    chains
    chordal

From d0e53d1f6c06558020dd755bae42a262746431b6 Mon Sep 17 00:00:00 2001
From: William Zijie Zhang <89562186+Transurgeon@users.noreply.github.com>
Date: Wed, 17 Jan 2024 13:44:36 -0500
Subject: [PATCH 125/129] Update networkx/algorithms/broadcasting.py

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/broadcasting.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
index db1453519a5..aaf351945c3 100644
--- a/networkx/algorithms/broadcasting.py
+++ b/networkx/algorithms/broadcasting.py
@@ -115,6 +115,8 @@ def tree_broadcast_time(G, node=None):
     of time required to complete broadcasting starting from the
     originator. The broadcast time of a graph is the maximum over
     all nodes of the minimum broadcast time from that node [1]_.
+    This function returns the minimum broadcast time of `node`.
+    If `node` is None the broadcast time for the graph is returned. 
 
     Parameters
     ----------

From 594aa9a917d9e3a59bd4aa158302dc9a98343e75 Mon Sep 17 00:00:00 2001
From: William Zijie Zhang <89562186+Transurgeon@users.noreply.github.com>
Date: Wed, 17 Jan 2024 13:44:52 -0500
Subject: [PATCH 126/129] Update networkx/algorithms/broadcasting.py

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/broadcasting.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
index aaf351945c3..33d742fcaf9 100644
--- a/networkx/algorithms/broadcasting.py
+++ b/networkx/algorithms/broadcasting.py
@@ -40,8 +40,8 @@ def tree_broadcast_center(G):
 
     The broadcast center of a graph G denotes the set of nodes having
     minimum broadcast time [1]_. This is a linear algorithm for determining
-    the broadcast center of a tree with N nodes, as a by-product it can also
-    determine the broadcast time from the broadcast center.
+    the broadcast center of a tree with N nodes, as a by-product it also
+    determines the broadcast time from the broadcast center.
 
     Parameters
     ----------

From 861476fce85538949fdfaea543c9d8b905c9be73 Mon Sep 17 00:00:00 2001
From: William Zijie Zhang <89562186+Transurgeon@users.noreply.github.com>
Date: Wed, 17 Jan 2024 13:45:04 -0500
Subject: [PATCH 127/129] Update networkx/algorithms/broadcasting.py

Co-authored-by: Dan Schult <dschult@colgate.edu>
---
 networkx/algorithms/broadcasting.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
index 33d742fcaf9..afe1e1f0508 100644
--- a/networkx/algorithms/broadcasting.py
+++ b/networkx/algorithms/broadcasting.py
@@ -140,9 +140,10 @@ def tree_broadcast_time(G, node=None):
 
     References
     ----------
-    .. [1] Harutyunyan, H. A. and Li, Z. "A Simple Construction of
-    Broadcast Graphs." In Computing and Combinatorics. COCOON 2019
-    (Ed. D. Z. Du and C. Tian.) Cham, Switzerland: Springer, pp. 240-253, 2019.
+    .. [1] Harutyunyan, H. A. and Li, Z.
+        "A Simple Construction of Broadcast Graphs."
+        In Computing and Combinatorics. COCOON 2019
+        (Ed. D. Z. Du and C. Tian.) Springer, pp. 240-253, 2019.
     """
     b_T, b_C = tree_broadcast_center(G)
     if node is not None:

From c349423bf15589556672f3afcee9a00a5455a8b9 Mon Sep 17 00:00:00 2001
From: Dan Schult <dschult@colgate.edu>
Date: Wed, 17 Jan 2024 21:54:11 -0500
Subject: [PATCH 128/129] Update networkx/algorithms/broadcasting.py

---
 networkx/algorithms/broadcasting.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
index afe1e1f0508..f4f5bb9a3d3 100644
--- a/networkx/algorithms/broadcasting.py
+++ b/networkx/algorithms/broadcasting.py
@@ -116,7 +116,7 @@ def tree_broadcast_time(G, node=None):
     originator. The broadcast time of a graph is the maximum over
     all nodes of the minimum broadcast time from that node [1]_.
     This function returns the minimum broadcast time of `node`.
-    If `node` is None the broadcast time for the graph is returned. 
+    If `node` is None the broadcast time for the graph is returned.
 
     Parameters
     ----------

From 3b59ba57816658c7c43d593a329bfb80a43bea6f Mon Sep 17 00:00:00 2001
From: Ross Barnowski <rossbar@berkeley.edu>
Date: Wed, 6 Mar 2024 22:48:28 -0800
Subject: [PATCH 129/129] Minor touchups.

---
 networkx/algorithms/broadcasting.py | 34 +++++++++++++----------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/networkx/algorithms/broadcasting.py b/networkx/algorithms/broadcasting.py
index f4f5bb9a3d3..094ac5e23b3 100644
--- a/networkx/algorithms/broadcasting.py
+++ b/networkx/algorithms/broadcasting.py
@@ -36,17 +36,16 @@ def _get_broadcast_centers(G, v, values, target):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 def tree_broadcast_center(G):
-    """Return the Broadcast Center of the tree G.
+    """Return the Broadcast Center of the tree `G`.
 
     The broadcast center of a graph G denotes the set of nodes having
     minimum broadcast time [1]_. This is a linear algorithm for determining
-    the broadcast center of a tree with N nodes, as a by-product it also
+    the broadcast center of a tree with ``N`` nodes, as a by-product it also
     determines the broadcast time from the broadcast center.
 
     Parameters
     ----------
-    G : NetworkX graph
-        Undirected graph
+    G : undirected graph
         The graph should be an undirected tree
 
     Returns
@@ -66,11 +65,11 @@ def tree_broadcast_center(G):
     """
     # Assert that the graph G is a tree
     if not nx.is_tree(G):
-        NetworkXError("Your graph is not a tree")
+        NetworkXError("Input graph is not a tree")
     # step 0
     if G.number_of_nodes() == 2:
         return 1, set(G.nodes())
-    elif G.number_of_nodes() == 1:
+    if G.number_of_nodes() == 1:
         return 0, set(G.nodes())
 
     # step 1
@@ -109,7 +108,7 @@ def tree_broadcast_center(G):
 @not_implemented_for("directed")
 @not_implemented_for("multigraph")
 def tree_broadcast_time(G, node=None):
-    """Return the Broadcast Time of the tree G.
+    """Return the Broadcast Time of the tree `G`.
 
     The minimum broadcast time of a node is defined as the minimum amount
     of time required to complete broadcasting starting from the
@@ -120,12 +119,10 @@ def tree_broadcast_time(G, node=None):
 
     Parameters
     ----------
-    G : NetworkX graph
-        Undirected graph
+    G : undirected graph
         The graph should be an undirected tree
-    node: int
-        index of starting node. If None,
-        the algorithm returns the broadcast
+    node: int, optional
+        index of starting node. If `None`, the algorithm returns the broadcast
         time of the tree.
 
     Returns
@@ -148,10 +145,9 @@ def tree_broadcast_time(G, node=None):
     b_T, b_C = tree_broadcast_center(G)
     if node is not None:
         return b_T + min(nx.shortest_path_length(G, node, u) for u in b_C)
-    else:
-        dist_from_center = dict.fromkeys(G, len(G))
-        for u in b_C:
-            for v, dist in nx.shortest_path_length(G, u).items():
-                if dist < dist_from_center[v]:
-                    dist_from_center[v] = dist
-        return b_T + max(dist_from_center.values())
+    dist_from_center = dict.fromkeys(G, len(G))
+    for u in b_C:
+        for v, dist in nx.shortest_path_length(G, u).items():
+            if dist < dist_from_center[v]:
+                dist_from_center[v] = dist
+    return b_T + max(dist_from_center.values())