Format w/ black

23 files changed, 1569 insertions, 1130 deletions

diff --git a/networkx/classes/coreviews.py b/networkx/classes/coreviews.py
index 1bacea92..e22f6855 100644
--- a/networkx/classes/coreviews.py
+++ b/networkx/classes/coreviews.py
@@ -2,12 +2,19 @@
 """
 from collections.abc import Mapping
 
-__all__ = ['AtlasView', 'AdjacencyView', 'MultiAdjacencyView',
-           'UnionAtlas', 'UnionAdjacency',
-           'UnionMultiInner', 'UnionMultiAdjacency',
-           'FilterAtlas', 'FilterAdjacency',
-           'FilterMultiInner', 'FilterMultiAdjacency',
-           ]
+__all__ = [
+    "AtlasView",
+    "AdjacencyView",
+    "MultiAdjacencyView",
+    "UnionAtlas",
+    "UnionAdjacency",
+    "UnionMultiInner",
+    "UnionMultiAdjacency",
+    "FilterAtlas",
+    "FilterAdjacency",
+    "FilterMultiInner",
+    "FilterMultiAdjacency",
+]
 
 
 class AtlasView(Mapping):
@@ -22,13 +29,14 @@ class AtlasView(Mapping):
     AdjacencyView - View into dict-of-dict-of-dict
     MultiAdjacencyView - View into dict-of-dict-of-dict-of-dict
     """
-    __slots__ = ('_atlas',)
+
+    __slots__ = ("_atlas",)
 
     def __getstate__(self):
-        return {'_atlas': self._atlas}
+        return {"_atlas": self._atlas}
 
     def __setstate__(self, state):
-        self._atlas = state['_atlas']
+        self._atlas = state["_atlas"]
 
     def __init__(self, d):
         self._atlas = d
@@ -49,7 +57,7 @@ class AtlasView(Mapping):
         return str(self._atlas)  # {nbr: self[nbr] for nbr in self})
 
     def __repr__(self):
-        return f'{self.__class__.__name__}({self._atlas!r})'
+        return f"{self.__class__.__name__}({self._atlas!r})"
 
 
 class AdjacencyView(AtlasView):
@@ -64,7 +72,8 @@ class AdjacencyView(AtlasView):
     AtlasView - View into dict-of-dict
     MultiAdjacencyView - View into dict-of-dict-of-dict-of-dict
     """
-    __slots__ = ()   # Still uses AtlasView slots names _atlas
+
+    __slots__ = ()  # Still uses AtlasView slots names _atlas
 
     def __getitem__(self, name):
         return AtlasView(self._atlas[name])
@@ -85,7 +94,8 @@ class MultiAdjacencyView(AdjacencyView):
     AtlasView - View into dict-of-dict
     AdjacencyView - View into dict-of-dict-of-dict
     """
-    __slots__ = ()   # Still uses AtlasView slots names _atlas
+
+    __slots__ = ()  # Still uses AtlasView slots names _atlas
 
     def __getitem__(self, name):
         return AdjacencyView(self._atlas[name])
@@ -107,14 +117,15 @@ class UnionAtlas(Mapping):
     UnionAdjacency - View into dict-of-dict-of-dict
     UnionMultiAdjacency - View into dict-of-dict-of-dict-of-dict
     """
-    __slots__ = ('_succ', '_pred')
+
+    __slots__ = ("_succ", "_pred")
 
     def __getstate__(self):
-        return {'_succ': self._succ, '_pred': self._pred}
+        return {"_succ": self._succ, "_pred": self._pred}
 
     def __setstate__(self, state):
-        self._succ = state['_succ']
-        self._pred = state['_pred']
+        self._succ = state["_succ"]
+        self._pred = state["_pred"]
 
     def __init__(self, succ, pred):
         self._succ = succ
@@ -145,7 +156,7 @@ class UnionAtlas(Mapping):
         return str({nbr: self[nbr] for nbr in self})
 
     def __repr__(self):
-        return f'{self.__class__.__name__}({self._succ!r}, {self._pred!r})'
+        return f"{self.__class__.__name__}({self._succ!r}, {self._pred!r})"
 
 
 class UnionAdjacency(Mapping):
@@ -165,18 +176,19 @@ class UnionAdjacency(Mapping):
     UnionAtlas - View into dict-of-dict
     UnionMultiAdjacency - View into dict-of-dict-of-dict-of-dict
     """
-    __slots__ = ('_succ', '_pred')
+
+    __slots__ = ("_succ", "_pred")
 
     def __getstate__(self):
-        return {'_succ': self._succ, '_pred': self._pred}
+        return {"_succ": self._succ, "_pred": self._pred}
 
     def __setstate__(self, state):
-        self._succ = state['_succ']
-        self._pred = state['_pred']
+        self._succ = state["_succ"]
+        self._pred = state["_pred"]
 
     def __init__(self, succ, pred):
         # keys must be the same for two input dicts
-        assert(len(set(succ.keys()) ^ set(pred.keys())) == 0)
+        assert len(set(succ.keys()) ^ set(pred.keys())) == 0
         self._succ = succ
         self._pred = pred
 
@@ -196,7 +208,7 @@ class UnionAdjacency(Mapping):
         return str({nbr: self[nbr] for nbr in self})
 
     def __repr__(self):
-        return f'{self.__class__.__name__}({self._succ!r}, {self._pred!r})'
+        return f"{self.__class__.__name__}({self._succ!r}, {self._pred!r})"
 
 
 class UnionMultiInner(UnionAtlas):
@@ -213,7 +225,8 @@ class UnionMultiInner(UnionAtlas):
     UnionAdjacency - View into dict-of-dict-of-dict
     UnionMultiAdjacency - View into dict-of-dict-of-dict-of-dict
     """
-    __slots__ = ()   # Still uses UnionAtlas slots names _succ, _pred
+
+    __slots__ = ()  # Still uses UnionAtlas slots names _succ, _pred
 
     def __getitem__(self, node):
         in_succ = node in self._succ
@@ -241,7 +254,8 @@ class UnionMultiAdjacency(UnionAdjacency):
     UnionAtlas - View into dict-of-dict
     UnionMultiInner - View into dict-of-dict-of-dict
     """
-    __slots__ = ()   # Still uses UnionAdjacency slots names _succ, _pred
+
+    __slots__ = ()  # Still uses UnionAdjacency slots names _succ, _pred
 
     def __getitem__(self, node):
         return UnionMultiInner(self._succ[node], self._pred[node])
@@ -275,10 +289,8 @@ class FilterAtlas(Mapping):  # nodedict, nbrdict, keydict
         except AttributeError:
             node_ok_shorter = False
         if node_ok_shorter:
-            return {u: self._atlas[u] for u in self.NODE_OK.nodes
-                    if u in self._atlas}
-        return {u: d for u, d in self._atlas.items()
-                if self.NODE_OK(u)}
+            return {u: self._atlas[u] for u in self.NODE_OK.nodes if u in self._atlas}
+        return {u: d for u, d in self._atlas.items() if self.NODE_OK(u)}
 
     def __str__(self):
         return str({nbr: self[nbr] for nbr in self})
@@ -287,7 +299,7 @@ class FilterAtlas(Mapping):  # nodedict, nbrdict, keydict
         return f"{self.__class__.__name__}({self._atlas!r}, {self.NODE_OK!r})"
 
 
-class FilterAdjacency(Mapping):   # edgedict
+class FilterAdjacency(Mapping):  # edgedict
     def __init__(self, d, NODE_OK, EDGE_OK):
         self._atlas = d
         self.NODE_OK = NODE_OK
@@ -307,8 +319,10 @@ class FilterAdjacency(Mapping):   # edgedict
 
     def __getitem__(self, node):
         if node in self._atlas and self.NODE_OK(node):
+
             def new_node_ok(nbr):
                 return self.NODE_OK(nbr) and self.EDGE_OK(node, nbr)
+
             return FilterAtlas(self._atlas[node], new_node_ok)
         raise KeyError(f"Key {node} not found")
 
@@ -318,13 +332,21 @@ class FilterAdjacency(Mapping):   # edgedict
         except AttributeError:
             node_ok_shorter = False
         if node_ok_shorter:
-            return {u: {v: d for v, d in self._atlas[u].items()
-                        if self.NODE_OK(v) if self.EDGE_OK(u, v)}
-                    for u in self.NODE_OK.nodes if u in self._atlas}
-        return {u: {v: d for v, d in nbrs.items() if self.NODE_OK(v)
-                    if self.EDGE_OK(u, v)}
-                for u, nbrs in self._atlas.items()
-                if self.NODE_OK(u)}
+            return {
+                u: {
+                    v: d
+                    for v, d in self._atlas[u].items()
+                    if self.NODE_OK(v)
+                    if self.EDGE_OK(u, v)
+                }
+                for u in self.NODE_OK.nodes
+                if u in self._atlas
+            }
+        return {
+            u: {v: d for v, d in nbrs.items() if self.NODE_OK(v) if self.EDGE_OK(u, v)}
+            for u, nbrs in self._atlas.items()
+            if self.NODE_OK(u)
+        }
 
     def __str__(self):
         return str({nbr: self[nbr] for nbr in self})
@@ -355,8 +377,10 @@ class FilterMultiInner(FilterAdjacency):  # muliedge_seconddict
 
     def __getitem__(self, nbr):
         if nbr in self._atlas and self.NODE_OK(nbr):
+
             def new_node_ok(key):
                 return self.EDGE_OK(nbr, key)
+
             return FilterAtlas(self._atlas[nbr], new_node_ok)
         raise KeyError(f"Key {nbr} not found")
 
@@ -366,18 +390,25 @@ class FilterMultiInner(FilterAdjacency):  # muliedge_seconddict
         except AttributeError:
             node_ok_shorter = False
         if node_ok_shorter:
-            return {v: {k: d for k, d in self._atlas[v].items()
-                        if self.EDGE_OK(v, k)}
-                    for v in self.NODE_OK.nodes if v in self._atlas}
-        return {v: {k: d for k, d in nbrs.items() if self.EDGE_OK(v, k)}
-                for v, nbrs in self._atlas.items() if self.NODE_OK(v)}
+            return {
+                v: {k: d for k, d in self._atlas[v].items() if self.EDGE_OK(v, k)}
+                for v in self.NODE_OK.nodes
+                if v in self._atlas
+            }
+        return {
+            v: {k: d for k, d in nbrs.items() if self.EDGE_OK(v, k)}
+            for v, nbrs in self._atlas.items()
+            if self.NODE_OK(v)
+        }
 
 
 class FilterMultiAdjacency(FilterAdjacency):  # multiedgedict
     def __getitem__(self, node):
         if node in self._atlas and self.NODE_OK(node):
+
             def edge_ok(nbr, key):
                 return self.NODE_OK(nbr) and self.EDGE_OK(node, nbr, key)
+
             return FilterMultiInner(self._atlas[node], self.NODE_OK, edge_ok)
         raise KeyError(f"Key {node} not found")
 
@@ -388,11 +419,21 @@ class FilterMultiAdjacency(FilterAdjacency):  # multiedgedict
             node_ok_shorter = False
         if node_ok_shorter:
             my_nodes = self.NODE_OK.nodes
-            return {u: {v: {k: d for k, d in kd.items()
-                            if self.EDGE_OK(u, v, k)}
-                        for v, kd in self._atlas[u].items() if v in my_nodes}
-                    for u in my_nodes if u in self._atlas}
-        return {u: {v: {k: d for k, d in kd.items()
-                        if self.EDGE_OK(u, v, k)}
-                    for v, kd in nbrs.items() if self.NODE_OK(v)}
-                for u, nbrs in self._atlas.items() if self.NODE_OK(u)}
+            return {
+                u: {
+                    v: {k: d for k, d in kd.items() if self.EDGE_OK(u, v, k)}
+                    for v, kd in self._atlas[u].items()
+                    if v in my_nodes
+                }
+                for u in my_nodes
+                if u in self._atlas
+            }
+        return {
+            u: {
+                v: {k: d for k, d in kd.items() if self.EDGE_OK(u, v, k)}
+                for v, kd in nbrs.items()
+                if self.NODE_OK(v)
+            }
+            for u, nbrs in self._atlas.items()
+            if self.NODE_OK(u)
+        }
diff --git a/networkx/classes/digraph.py b/networkx/classes/digraph.py
index f8b3c61d..10ab4e0f 100644
--- a/networkx/classes/digraph.py
+++ b/networkx/classes/digraph.py
@@ -4,8 +4,13 @@ from copy import deepcopy
 import networkx as nx
 from networkx.classes.graph import Graph
 from networkx.classes.coreviews import AdjacencyView
-from networkx.classes.reportviews import OutEdgeView, InEdgeView, \
-    DiDegreeView, InDegreeView, OutDegreeView
+from networkx.classes.reportviews import (
+    OutEdgeView,
+    InEdgeView,
+    DiDegreeView,
+    InDegreeView,
+    OutDegreeView,
+)
 from networkx.exception import NetworkXError
 import networkx.convert as convert
 
@@ -521,11 +526,11 @@ class DiGraph(Graph):
         except KeyError as e:  # NetworkXError if n not in self
             raise NetworkXError(f"The node {n} is not in the digraph.") from e
         for u in nbrs:
-            del self._pred[u][n]   # remove all edges n-u in digraph
-        del self._succ[n]          # remove node from succ
+            del self._pred[u][n]  # remove all edges n-u in digraph
+        del self._succ[n]  # remove node from succ
         for u in self._pred[n]:
-            del self._succ[u][n]   # remove all edges n-u in digraph
-        del self._pred[n]          # remove node from pred
+            del self._succ[u][n]  # remove all edges n-u in digraph
+        del self._pred[n]  # remove node from pred
 
     def remove_nodes_from(self, nodes):
         """Remove multiple nodes.
@@ -556,11 +561,11 @@ class DiGraph(Graph):
                 succs = self._succ[n]
                 del self._node[n]
                 for u in succs:
-                    del self._pred[u][n]   # remove all edges n-u in digraph
-                del self._succ[n]          # now remove node
+                    del self._pred[u][n]  # remove all edges n-u in digraph
+                del self._succ[n]  # now remove node
                 for u in self._pred[n]:
-                    del self._succ[u][n]   # remove all edges n-u in digraph
-                del self._pred[n]          # now remove node
+                    del self._succ[u][n]  # remove all edges n-u in digraph
+                del self._pred[n]  # now remove node
             except KeyError:
                 pass  # silent failure on remove
 
@@ -761,14 +766,14 @@ class DiGraph(Graph):
 
         This is true if graph has the edge u->v.
         """
-        return (u in self._succ and v in self._succ[u])
+        return u in self._succ and v in self._succ[u]
 
     def has_predecessor(self, u, v):
         """Returns True if node u has predecessor v.
 
         This is true if graph has the edge u<-v.
         """
-        return (u in self._pred and v in self._pred[u])
+        return u in self._pred and v in self._pred[u]
 
     def successors(self, n):
         """Returns an iterator over successor nodes of n.
@@ -1176,14 +1181,18 @@ class DiGraph(Graph):
         G.graph.update(deepcopy(self.graph))
         G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
         if reciprocal is True:
-            G.add_edges_from((u, v, deepcopy(d))
-                             for u, nbrs in self._adj.items()
-                             for v, d in nbrs.items()
-                             if v in self._pred[u])
+            G.add_edges_from(
+                (u, v, deepcopy(d))
+                for u, nbrs in self._adj.items()
+                for v, d in nbrs.items()
+                if v in self._pred[u]
+            )
         else:
-            G.add_edges_from((u, v, deepcopy(d))
-                             for u, nbrs in self._adj.items()
-                             for v, d in nbrs.items())
+            G.add_edges_from(
+                (u, v, deepcopy(d))
+                for u, nbrs in self._adj.items()
+                for v, d in nbrs.items()
+            )
         return G
 
     def reverse(self, copy=True):
@@ -1203,7 +1212,6 @@ class DiGraph(Graph):
             H = self.__class__()
             H.graph.update(deepcopy(self.graph))
             H.add_nodes_from((n, deepcopy(d)) for n, d in self.nodes.items())
-            H.add_edges_from((v, u, deepcopy(d)) for u, v, d
-                             in self.edges(data=True))
+            H.add_edges_from((v, u, deepcopy(d)) for u, v, d in self.edges(data=True))
             return H
         return nx.graphviews.reverse_view(self)
diff --git a/networkx/classes/filters.py b/networkx/classes/filters.py
index 067da1d1..aefcbdf3 100644
--- a/networkx/classes/filters.py
+++ b/networkx/classes/filters.py
@@ -2,13 +2,19 @@
 
 These filters return the function used when creating `SubGraph`.
 """
-__all__ = ['no_filter', 'hide_nodes',
-           'hide_edges', 'hide_multiedges',
-           'hide_diedges', 'hide_multidiedges',
-           'show_nodes',
-           'show_edges', 'show_multiedges',
-           'show_diedges', 'show_multidiedges',
-           ]
+__all__ = [
+    "no_filter",
+    "hide_nodes",
+    "hide_edges",
+    "hide_multiedges",
+    "hide_diedges",
+    "hide_multidiedges",
+    "show_nodes",
+    "show_edges",
+    "show_multiedges",
+    "show_diedges",
+    "show_multidiedges",
+]
 
 
 def no_filter(*items):
diff --git a/networkx/classes/function.py b/networkx/classes/function.py
index 8e199e9a..a24b3926 100644
--- a/networkx/classes/function.py
+++ b/networkx/classes/function.py
@@ -9,20 +9,46 @@ from networkx.utils import pairwise, not_implemented_for
 
 from networkx.classes.graphviews import subgraph_view, reverse_view
 
-__all__ = ['nodes', 'edges', 'degree', 'degree_histogram', 'neighbors',
-           'number_of_nodes', 'number_of_edges', 'density',
-           'is_directed', 'info', 'freeze', 'is_frozen',
-           'subgraph', 'subgraph_view', 'induced_subgraph', 'reverse_view',
-           'edge_subgraph', 'restricted_view',
-           'to_directed', 'to_undirected',
-           'add_star', 'add_path', 'add_cycle',
-           'create_empty_copy', 'set_node_attributes',
-           'get_node_attributes', 'set_edge_attributes',
-           'get_edge_attributes', 'all_neighbors', 'non_neighbors',
-           'non_edges', 'common_neighbors', 'is_weighted',
-           'is_negatively_weighted', 'is_empty',
-           'selfloop_edges', 'nodes_with_selfloops', 'number_of_selfloops',
-           ]
+__all__ = [
+    "nodes",
+    "edges",
+    "degree",
+    "degree_histogram",
+    "neighbors",
+    "number_of_nodes",
+    "number_of_edges",
+    "density",
+    "is_directed",
+    "info",
+    "freeze",
+    "is_frozen",
+    "subgraph",
+    "subgraph_view",
+    "induced_subgraph",
+    "reverse_view",
+    "edge_subgraph",
+    "restricted_view",
+    "to_directed",
+    "to_undirected",
+    "add_star",
+    "add_path",
+    "add_cycle",
+    "create_empty_copy",
+    "set_node_attributes",
+    "get_node_attributes",
+    "set_edge_attributes",
+    "get_edge_attributes",
+    "all_neighbors",
+    "non_neighbors",
+    "non_edges",
+    "common_neighbors",
+    "is_weighted",
+    "is_negatively_weighted",
+    "is_empty",
+    "selfloop_edges",
+    "nodes_with_selfloops",
+    "number_of_selfloops",
+]
 
 
 def nodes(G):
@@ -293,7 +319,9 @@ def add_cycle(G_to_add_to, nodes_for_cycle, **attr):
     except StopIteration:
         return
     G_to_add_to.add_node(first_node)
-    G_to_add_to.add_edges_from(pairwise(chain((first_node,), nlist), cyclic=True), **attr)
+    G_to_add_to.add_edges_from(
+        pairwise(chain((first_node,), nlist), cyclic=True), **attr
+    )
 
 
 def subgraph(G, nbunch):
@@ -548,7 +576,7 @@ def info(G, n=None):
         If n is not in the graph G
 
     """
-    info = ''  # append this all to a string
+    info = ""  # append this all to a string
     if n is None:
         info += f"Name: {G.name}\n"
         type_name = [type(G).__name__]
@@ -571,7 +599,7 @@ def info(G, n=None):
         info += f"Node {n} has the following properties:\n"
         info += f"Degree: {G.degree(n)}\n"
         info += "Neighbors: "
-        info += ' '.join(str(nbr) for nbr in G.neighbors(n))
+        info += " ".join(str(nbr) for nbr in G.neighbors(n))
     return info
 
 
@@ -892,7 +920,7 @@ def non_edges(graph):
                 yield (u, v)
 
 
-@not_implemented_for('directed')
+@not_implemented_for("directed")
 def common_neighbors(G, u, v):
     """Returns the common neighbors of two nodes in a graph.
 
@@ -921,16 +949,16 @@ def common_neighbors(G, u, v):
     [2, 3, 4]
     """
     if u not in G:
-        raise nx.NetworkXError('u is not in the graph.')
+        raise nx.NetworkXError("u is not in the graph.")
     if v not in G:
-        raise nx.NetworkXError('v is not in the graph.')
+        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))
 
 
-def is_weighted(G, edge=None, weight='weight'):
+def is_weighted(G, edge=None, weight="weight"):
     """Returns True if `G` has weighted edges.
 
     Parameters
@@ -972,7 +1000,7 @@ def is_weighted(G, edge=None, weight='weight'):
     if edge is not None:
         data = G.get_edge_data(*edge)
         if data is None:
-            msg = f'Edge {edge!r} does not exist.'
+            msg = f"Edge {edge!r} does not exist."
             raise nx.NetworkXError(msg)
         return weight in data
 
@@ -983,7 +1011,7 @@ def is_weighted(G, edge=None, weight='weight'):
     return all(weight in data for u, v, data in G.edges(data=True))
 
 
-def is_negatively_weighted(G, edge=None, weight='weight'):
+def is_negatively_weighted(G, edge=None, weight="weight"):
     """Returns True if `G` has negatively weighted edges.
 
     Parameters
@@ -1029,12 +1057,11 @@ def is_negatively_weighted(G, edge=None, weight='weight'):
     if edge is not None:
         data = G.get_edge_data(*edge)
         if data is None:
-            msg = f'Edge {edge!r} does not exist.'
+            msg = f"Edge {edge!r} does not exist."
             raise nx.NetworkXError(msg)
         return weight in data and data[weight] < 0
 
-    return any(weight in data and data[weight] < 0
-               for u, v, data in G.edges(data=True))
+    return any(weight in data and data[weight] < 0 for u, v, data in G.edges(data=True))
 
 
 def is_empty(G):
@@ -1130,38 +1157,56 @@ def selfloop_edges(G, data=False, keys=False, default=None):
     if data is True:
         if G.is_multigraph():
             if keys is True:
-                return ((n, n, k, d)
-                        for n, nbrs in G.adj.items()
-                        if n in nbrs for k, d in nbrs[n].items())
+                return (
+                    (n, n, k, d)
+                    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()
-                        if n in nbrs for d in nbrs[n].values())
+                return (
+                    (n, n, d)
+                    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)
     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()
-                        if n in nbrs for k, d in nbrs[n].items())
+                return (
+                    (n, n, k, d.get(data, default))
+                    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()
-                        if n in nbrs for d in nbrs[n].values())
+                return (
+                    (n, n, d.get(data, default))
+                    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() if n in nbrs)
+            return (
+                (n, n, nbrs[n].get(data, default))
+                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])
+                return (
+                    (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()
-                        if n in nbrs for d in nbrs[n].values())
+                return (
+                    (n, n)
+                    for n, nbrs in G.adj.items()
+                    if n in nbrs
+                    for d in nbrs[n].values()
+                )
         else:
             return ((n, n) for n, nbrs in G.adj.items() if n in nbrs)
 
diff --git a/networkx/classes/graph.py b/networkx/classes/graph.py
index 8731525f..a25eafb8 100644
--- a/networkx/classes/graph.py
+++ b/networkx/classes/graph.py
@@ -261,6 +261,7 @@ class Graph:
     creating graph subclasses by overwriting the base class `dict` with
     a dictionary-like object.
     """
+
     node_dict_factory = dict
     node_attr_dict_factory = dict
     adjlist_outer_dict_factory = dict
@@ -324,7 +325,7 @@ class Graph:
         self.adjlist_inner_dict_factory = self.adjlist_inner_dict_factory
         self.edge_attr_dict_factory = self.edge_attr_dict_factory
 
-        self.graph = self.graph_attr_dict_factory()   # dictionary for graph attributes
+        self.graph = self.graph_attr_dict_factory()  # dictionary for graph attributes
         self._node = self.node_dict_factory()  # empty node attribute dict
         self._adj = self.adjlist_outer_dict_factory()  # empty adjacency dict
         # attempt to load graph with data
@@ -360,11 +361,11 @@ class Graph:
         keyed by the string `"name"`. as well as an attribute (technically
         a property) `G.name`. This is entirely user controlled.
         """
-        return self.graph.get('name', '')
+        return self.graph.get("name", "")
 
     @name.setter
     def name(self, s):
-        self.graph['name'] = s
+        self.graph["name"] = s
 
     def __str__(self):
         """Returns the graph name.
@@ -612,8 +613,8 @@ class Graph:
         except KeyError as e:  # NetworkXError if n not in self
             raise NetworkXError(f"The node {n} is not in the graph.") from e
         for u in nbrs:
-            del adj[u][n]   # remove all edges n-u in graph
-        del adj[n]          # now remove node
+            del adj[u][n]  # remove all edges n-u in graph
+        del adj[n]  # now remove node
 
     def remove_nodes_from(self, nodes):
         """Remove multiple nodes.
@@ -644,7 +645,7 @@ class Graph:
         for n in nodes:
             try:
                 del self._node[n]
-                for u in list(adj[n]):   # list handles self-loops
+                for u in list(adj[n]):  # list handles self-loops
                     del adj[u][n]  # (allows mutation of dict in loop)
                 del adj[n]
             except KeyError:
@@ -745,7 +746,7 @@ class Graph:
         # Lazy View creation: overload the (class) property on the instance
         # Then future G.nodes use the existing View
         # setattr doesn't work because attribute already exists
-        self.__dict__['nodes'] = nodes
+        self.__dict__["nodes"] = nodes
         return nodes
 
     def number_of_nodes(self):
@@ -937,7 +938,7 @@ class Graph:
             self._adj[u][v] = datadict
             self._adj[v][u] = datadict
 
-    def add_weighted_edges_from(self, ebunch_to_add, weight='weight', **attr):
+    def add_weighted_edges_from(self, ebunch_to_add, weight="weight", **attr):
         """Add weighted edges in `ebunch_to_add` with specified weight attr
 
         Parameters
@@ -967,8 +968,7 @@ class Graph:
         >>> G = nx.Graph()   # or DiGraph, MultiGraph, MultiDiGraph, etc
         >>> G.add_weighted_edges_from([(0, 1, 3.0), (1, 2, 7.5)])
         """
-        self.add_edges_from(((u, v, {weight: d}) for u, v, d in ebunch_to_add),
-                            **attr)
+        self.add_edges_from(((u, v, {weight: d}) for u, v, d in ebunch_to_add), **attr)
 
     def remove_edge(self, u, v):
         """Remove the edge between u and v.
@@ -1511,9 +1511,11 @@ class Graph:
         G = self.__class__()
         G.graph.update(self.graph)
         G.add_nodes_from((n, d.copy()) for n, d in self._node.items())
-        G.add_edges_from((u, v, datadict.copy())
-                         for u, nbrs in self._adj.items()
-                         for v, datadict in nbrs.items())
+        G.add_edges_from(
+            (u, v, datadict.copy())
+            for u, nbrs in self._adj.items()
+            for v, datadict in nbrs.items()
+        )
         return G
 
     def to_directed(self, as_view=False):
@@ -1565,9 +1567,11 @@ class Graph:
         G = graph_class()
         G.graph.update(deepcopy(self.graph))
         G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
-        G.add_edges_from((u, v, deepcopy(data))
-                         for u, nbrs in self._adj.items()
-                         for v, data in nbrs.items())
+        G.add_edges_from(
+            (u, v, deepcopy(data))
+            for u, nbrs in self._adj.items()
+            for v, data in nbrs.items()
+        )
         return G
 
     def to_undirected(self, as_view=False):
@@ -1620,9 +1624,11 @@ class Graph:
         G = graph_class()
         G.graph.update(deepcopy(self.graph))
         G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
-        G.add_edges_from((u, v, deepcopy(d))
-                         for u, nbrs in self._adj.items()
-                         for v, d in nbrs.items())
+        G.add_edges_from(
+            (u, v, deepcopy(d))
+            for u, nbrs in self._adj.items()
+            for v, d in nbrs.items()
+        )
         return G
 
     def subgraph(self, nodes):
@@ -1685,7 +1691,7 @@ class Graph:
         induced_nodes = nx.filters.show_nodes(self.nbunch_iter(nodes))
         # if already a subgraph, don't make a chain
         subgraph = nx.graphviews.subgraph_view
-        if hasattr(self, '_NODE_OK'):
+        if hasattr(self, "_NODE_OK"):
             return subgraph(self._graph, induced_nodes, self._EDGE_OK)
         return subgraph(self, induced_nodes)
 
@@ -1864,11 +1870,12 @@ class Graph:
         or None, a :exc:`NetworkXError` is raised.  Also, if any object in
         nbunch is not hashable, a :exc:`NetworkXError` is raised.
         """
-        if nbunch is None:   # include all nodes via iterator
+        if nbunch is None:  # include all nodes via iterator
             bunch = iter(self._adj)
         elif nbunch in self:  # if nbunch is a single node
             bunch = iter([nbunch])
-        else:                # if nbunch is a sequence of nodes
+        else:  # if nbunch is a sequence of nodes
+
             def bunch_iter(nlist, adj):
                 try:
                     for n in nlist:
@@ -1877,14 +1884,15 @@ class Graph:
                 except TypeError as e:
                     message = e.args[0]
                     # capture error for non-sequence/iterator nbunch.
-                    if 'iter' in message:
+                    if "iter" in message:
                         msg = "nbunch is not a node or a sequence of nodes."
                         raise NetworkXError(msg) from e
                     # capture error for unhashable node.
-                    elif 'hashable' in message:
+                    elif "hashable" in message:
                         msg = f"Node {n} in sequence nbunch is not a valid node."
                         raise NetworkXError(msg) from e
                     else:
                         raise
+
             bunch = bunch_iter(nbunch, self._adj)
         return bunch
diff --git a/networkx/classes/graphviews.py b/networkx/classes/graphviews.py
index b0633404..6d565a69 100644
--- a/networkx/classes/graphviews.py
+++ b/networkx/classes/graphviews.py
@@ -23,15 +23,20 @@ the chain is tricky and much harder with restricted_views than
 with induced subgraphs.
 Often it is easiest to use .copy() to avoid chains.
 """
-from networkx.classes.coreviews import UnionAdjacency, UnionMultiAdjacency, \
-    FilterAtlas, FilterAdjacency, FilterMultiAdjacency
+from networkx.classes.coreviews import (
+    UnionAdjacency,
+    UnionMultiAdjacency,
+    FilterAtlas,
+    FilterAdjacency,
+    FilterMultiAdjacency,
+)
 from networkx.classes.filters import no_filter
 from networkx.exception import NetworkXError
 from networkx.utils import not_implemented_for
 
 import networkx as nx
 
-__all__ = ['generic_graph_view', 'subgraph_view', 'reverse_view']
+__all__ = ["generic_graph_view", "subgraph_view", "reverse_view"]
 
 
 def generic_graph_view(G, create_using=None):
@@ -159,11 +164,15 @@ def subgraph_view(G, filter_node=no_filter, filter_edge=no_filter):
     if G.is_multigraph():
         Adj = FilterMultiAdjacency
 
-        def reverse_edge(u, v, k): return filter_edge(v, u, k)
+        def reverse_edge(u, v, k):
+            return filter_edge(v, u, k)
+
     else:
         Adj = FilterAdjacency
 
-        def reverse_edge(u, v): return filter_edge(v, u)
+        def reverse_edge(u, v):
+            return filter_edge(v, u)
+
     if G.is_directed():
         newG._succ = Adj(G._succ, filter_node, filter_edge)
         newG._pred = Adj(G._pred, filter_node, reverse_edge)
@@ -173,7 +182,7 @@ def subgraph_view(G, filter_node=no_filter, filter_edge=no_filter):
     return newG
 
 
-@not_implemented_for('undirected')
+@not_implemented_for("undirected")
 def reverse_view(G):
     """ View of `G` with edge directions reversed
 
diff --git a/networkx/classes/multidigraph.py b/networkx/classes/multidigraph.py
index bff422d4..59a3f44d 100644
--- a/networkx/classes/multidigraph.py
+++ b/networkx/classes/multidigraph.py
@@ -5,8 +5,13 @@ import networkx as nx
 from networkx.classes.digraph import DiGraph
 from networkx.classes.multigraph import MultiGraph
 from networkx.classes.coreviews import MultiAdjacencyView
-from networkx.classes.reportviews import OutMultiEdgeView, InMultiEdgeView, \
-    DiMultiDegreeView, OutMultiDegreeView, InMultiDegreeView
+from networkx.classes.reportviews import (
+    OutMultiEdgeView,
+    InMultiEdgeView,
+    DiMultiDegreeView,
+    OutMultiDegreeView,
+    InMultiDegreeView,
+)
 from networkx.exception import NetworkXError
 
 
@@ -254,6 +259,7 @@ class MultiDiGraph(MultiGraph, DiGraph):
     creating graph subclasses by overwriting the base class `dict` with
     a dictionary-like object.
     """
+
     # node_dict_factory = dict    # already assigned in Graph
     # adjlist_outer_dict_factory = dict
     # adjlist_inner_dict_factory = dict
@@ -824,16 +830,20 @@ class MultiDiGraph(MultiGraph, DiGraph):
         G.graph.update(deepcopy(self.graph))
         G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
         if reciprocal is True:
-            G.add_edges_from((u, v, key, deepcopy(data))
-                             for u, nbrs in self._adj.items()
-                             for v, keydict in nbrs.items()
-                             for key, data in keydict.items()
-                             if v in self._pred[u] and key in self._pred[u][v])
+            G.add_edges_from(
+                (u, v, key, deepcopy(data))
+                for u, nbrs in self._adj.items()
+                for v, keydict in nbrs.items()
+                for key, data in keydict.items()
+                if v in self._pred[u] and key in self._pred[u][v]
+            )
         else:
-            G.add_edges_from((u, v, key, deepcopy(data))
-                             for u, nbrs in self._adj.items()
-                             for v, keydict in nbrs.items()
-                             for key, data in keydict.items())
+            G.add_edges_from(
+                (u, v, key, deepcopy(data))
+                for u, nbrs in self._adj.items()
+                for v, keydict in nbrs.items()
+                for key, data in keydict.items()
+            )
         return G
 
     def reverse(self, copy=True):
@@ -853,7 +863,9 @@ class MultiDiGraph(MultiGraph, DiGraph):
             H = self.__class__()
             H.graph.update(deepcopy(self.graph))
             H.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
-            H.add_edges_from((v, u, k, deepcopy(d)) for u, v, k, d
-                             in self.edges(keys=True, data=True))
+            H.add_edges_from(
+                (v, u, k, deepcopy(d))
+                for u, v, k, d in self.edges(keys=True, data=True)
+            )
             return H
         return nx.graphviews.reverse_view(self)
diff --git a/networkx/classes/multigraph.py b/networkx/classes/multigraph.py
index ebf70f44..d3685b14 100644
--- a/networkx/classes/multigraph.py
+++ b/networkx/classes/multigraph.py
@@ -252,6 +252,7 @@ class MultiGraph(Graph):
     creating graph subclasses by overwriting the base class `dict` with
     a dictionary-like object.
     """
+
     # node_dict_factory = dict    # already assigned in Graph
     # adjlist_outer_dict_factory = dict
     # adjlist_inner_dict_factory = dict
@@ -956,10 +957,12 @@ class MultiGraph(Graph):
         G = self.__class__()
         G.graph.update(self.graph)
         G.add_nodes_from((n, d.copy()) for n, d in self._node.items())
-        G.add_edges_from((u, v, key, datadict.copy())
-                         for u, nbrs in self._adj.items()
-                         for v, keydict in nbrs.items()
-                         for key, datadict in keydict.items())
+        G.add_edges_from(
+            (u, v, key, datadict.copy())
+            for u, nbrs in self._adj.items()
+            for v, keydict in nbrs.items()
+            for key, datadict in keydict.items()
+        )
         return G
 
     def to_directed(self, as_view=False):
@@ -1011,10 +1014,12 @@ class MultiGraph(Graph):
         G = graph_class()
         G.graph.update(deepcopy(self.graph))
         G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
-        G.add_edges_from((u, v, key, deepcopy(datadict))
-                         for u, nbrs in self.adj.items()
-                         for v, keydict in nbrs.items()
-                         for key, datadict in keydict.items())
+        G.add_edges_from(
+            (u, v, key, deepcopy(datadict))
+            for u, nbrs in self.adj.items()
+            for v, keydict in nbrs.items()
+            for key, datadict in keydict.items()
+        )
         return G
 
     def to_undirected(self, as_view=False):
@@ -1062,10 +1067,12 @@ class MultiGraph(Graph):
         G = graph_class()
         G.graph.update(deepcopy(self.graph))
         G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
-        G.add_edges_from((u, v, key, deepcopy(datadict))
-                         for u, nbrs in self._adj.items()
-                         for v, keydict in nbrs.items()
-                         for key, datadict in keydict.items())
+        G.add_edges_from(
+            (u, v, key, deepcopy(datadict))
+            for u, nbrs in self._adj.items()
+            for v, keydict in nbrs.items()
+            for key, datadict in keydict.items()
+        )
         return G
 
     def number_of_edges(self, u=None, v=None):
diff --git a/networkx/classes/ordered.py b/networkx/classes/ordered.py
index ba8e6d78..2cb03c71 100644
--- a/networkx/classes/ordered.py
+++ b/networkx/classes/ordered.py
@@ -36,16 +36,14 @@ from .multidigraph import MultiDiGraph
 
 __all__ = []
 
-__all__.extend([
-    'OrderedGraph',
-    'OrderedDiGraph',
-    'OrderedMultiGraph',
-    'OrderedMultiDiGraph',
-])
+__all__.extend(
+    ["OrderedGraph", "OrderedDiGraph", "OrderedMultiGraph", "OrderedMultiDiGraph",]
+)
 
 
 class OrderedGraph(Graph):
     """Consistently ordered variant of :class:`~networkx.Graph`."""
+
     node_dict_factory = OrderedDict
     adjlist_outer_dict_factory = OrderedDict
     adjlist_inner_dict_factory = OrderedDict
@@ -54,6 +52,7 @@ class OrderedGraph(Graph):
 
 class OrderedDiGraph(DiGraph):
     """Consistently ordered variant of :class:`~networkx.DiGraph`."""
+
     node_dict_factory = OrderedDict
     adjlist_outer_dict_factory = OrderedDict
     adjlist_inner_dict_factory = OrderedDict
@@ -62,6 +61,7 @@ class OrderedDiGraph(DiGraph):
 
 class OrderedMultiGraph(MultiGraph):
     """Consistently ordered variant of :class:`~networkx.MultiGraph`."""
+
     node_dict_factory = OrderedDict
     adjlist_outer_dict_factory = OrderedDict
     adjlist_inner_dict_factory = OrderedDict
@@ -71,6 +71,7 @@ class OrderedMultiGraph(MultiGraph):
 
 class OrderedMultiDiGraph(MultiDiGraph):
     """Consistently ordered variant of :class:`~networkx.MultiDiGraph`."""
+
     node_dict_factory = OrderedDict
     adjlist_outer_dict_factory = OrderedDict
     adjlist_inner_dict_factory = OrderedDict
diff --git a/networkx/classes/reportviews.py b/networkx/classes/reportviews.py
index 73f1eeb1..2b867f29 100644
--- a/networkx/classes/reportviews.py
+++ b/networkx/classes/reportviews.py
@@ -84,14 +84,30 @@ EdgeDataView
 """
 from collections.abc import Mapping, Set
 
-__all__ = ['NodeView', 'NodeDataView',
-           'EdgeView', 'OutEdgeView', 'InEdgeView',
-           'EdgeDataView', 'OutEdgeDataView', 'InEdgeDataView',
-           'MultiEdgeView', 'OutMultiEdgeView', 'InMultiEdgeView',
-           'MultiEdgeDataView', 'OutMultiEdgeDataView', 'InMultiEdgeDataView',
-           'DegreeView', 'DiDegreeView', 'InDegreeView', 'OutDegreeView',
-           'MultiDegreeView', 'DiMultiDegreeView',
-           'InMultiDegreeView', 'OutMultiDegreeView']
+__all__ = [
+    "NodeView",
+    "NodeDataView",
+    "EdgeView",
+    "OutEdgeView",
+    "InEdgeView",
+    "EdgeDataView",
+    "OutEdgeDataView",
+    "InEdgeDataView",
+    "MultiEdgeView",
+    "OutMultiEdgeView",
+    "InMultiEdgeView",
+    "MultiEdgeDataView",
+    "OutMultiEdgeDataView",
+    "InMultiEdgeDataView",
+    "DegreeView",
+    "DiDegreeView",
+    "InDegreeView",
+    "OutDegreeView",
+    "MultiDegreeView",
+    "DiMultiDegreeView",
+    "InMultiDegreeView",
+    "OutMultiDegreeView",
+]
 
 
 # NodeViews
@@ -145,13 +161,14 @@ class NodeView(Mapping, Set):
     >>> NVdata[2] == NV[2]  # NVdata gets 'color', NV gets datadict
     False
     """
-    __slots__ = '_nodes',
+
+    __slots__ = ("_nodes",)
 
     def __getstate__(self):
-        return {'_nodes': self._nodes}
+        return {"_nodes": self._nodes}
 
     def __setstate__(self, state):
-        self._nodes = state['_nodes']
+        self._nodes = state["_nodes"]
 
     def __init__(self, graph):
         self._nodes = graph._node
@@ -209,17 +226,16 @@ class NodeDataView(Set):
     data : bool or string (default=False)
     default : object (default=None)
     """
-    __slots__ = ('_nodes', '_data', '_default')
+
+    __slots__ = ("_nodes", "_data", "_default")
 
     def __getstate__(self):
-        return {'_nodes': self._nodes,
-                '_data': self._data,
-                '_default': self._default}
+        return {"_nodes": self._nodes, "_data": self._data, "_default": self._default}
 
     def __setstate__(self, state):
-        self._nodes = state['_nodes']
-        self._data = state['_data']
-        self._default = state['_default']
+        self._nodes = state["_nodes"]
+        self._data = state["_data"]
+        self._default = state["_default"]
 
     def __init__(self, nodedict, data=False, default=None):
         self._nodes = nodedict
@@ -245,8 +261,10 @@ class NodeDataView(Set):
             return iter(self._nodes)
         if data is True:
             return iter(self._nodes.items())
-        return ((n, dd[data] if data in dd else self._default)
-                for n, dd in self._nodes.items())
+        return (
+            (n, dd[data] if data in dd else self._default)
+            for n, dd in self._nodes.items()
+        )
 
     def __contains__(self, n):
         try:
@@ -324,8 +342,7 @@ class DiDegreeView:
         self._graph = G
         self._succ = G._succ if hasattr(G, "_succ") else G._adj
         self._pred = G._pred if hasattr(G, "_pred") else G._adj
-        self._nodes = self._succ if nbunch is None \
-            else list(G.nbunch_iter(nbunch))
+        self._nodes = self._succ if nbunch is None else list(G.nbunch_iter(nbunch))
         self._weight = weight
 
     def __call__(self, nbunch=None, weight=None):
@@ -348,8 +365,9 @@ class DiDegreeView:
         preds = self._pred[n]
         if weight is None:
             return len(succs) + len(preds)
-        return sum(dd.get(weight, 1) for dd in succs.values()) + \
-            sum(dd.get(weight, 1) for dd in preds.values())
+        return sum(dd.get(weight, 1) for dd in succs.values()) + sum(
+            dd.get(weight, 1) for dd in preds.values()
+        )
 
     def __iter__(self):
         weight = self._weight
@@ -362,8 +380,9 @@ class DiDegreeView:
             for n in self._nodes:
                 succs = self._succ[n]
                 preds = self._pred[n]
-                deg = sum(dd.get(weight, 1) for dd in succs.values()) \
-                    + sum(dd.get(weight, 1) for dd in preds.values())
+                deg = sum(dd.get(weight, 1) for dd in succs.values()) + sum(
+                    dd.get(weight, 1) for dd in preds.values()
+                )
                 yield (n, deg)
 
     def __len__(self):
@@ -425,8 +444,9 @@ class DegreeView(DiDegreeView):
         nbrs = self._succ[n]
         if weight is None:
             return len(nbrs) + (n in nbrs)
-        return sum(dd.get(weight, 1) for dd in nbrs.values()) + \
-            (n in nbrs and nbrs[n].get(weight, 1))
+        return sum(dd.get(weight, 1) for dd in nbrs.values()) + (
+            n in nbrs and nbrs[n].get(weight, 1)
+        )
 
     def __iter__(self):
         weight = self._weight
@@ -437,8 +457,9 @@ class DegreeView(DiDegreeView):
         else:
             for n in self._nodes:
                 nbrs = self._succ[n]
-                deg = sum(dd.get(weight, 1) for dd in nbrs.values()) + \
-                    (n in nbrs and nbrs[n].get(weight, 1))
+                deg = sum(dd.get(weight, 1) for dd in nbrs.values()) + (
+                    n in nbrs and nbrs[n].get(weight, 1)
+                )
                 yield (n, deg)
 
 
@@ -495,11 +516,13 @@ class MultiDegreeView(DiDegreeView):
         weight = self._weight
         nbrs = self._succ[n]
         if weight is None:
-            return sum(len(keys) for keys in nbrs.values()) + \
-                (n in nbrs and len(nbrs[n]))
+            return sum(len(keys) for keys in nbrs.values()) + (
+                n in nbrs and len(nbrs[n])
+            )
         # edge weighted graph - degree is sum of nbr edge weights
-        deg = sum(d.get(weight, 1) for key_dict in nbrs.values()
-                  for d in key_dict.values())
+        deg = sum(
+            d.get(weight, 1) for key_dict in nbrs.values() for d in key_dict.values()
+        )
         if n in nbrs:
             deg += sum(d.get(weight, 1) for d in nbrs[n].values())
         return deg
@@ -509,14 +532,18 @@ class MultiDegreeView(DiDegreeView):
         if weight is None:
             for n in self._nodes:
                 nbrs = self._succ[n]
-                deg = sum(len(keys) for keys in nbrs.values()) + \
-                    (n in nbrs and len(nbrs[n]))
+                deg = sum(len(keys) for keys in nbrs.values()) + (
+                    n in nbrs and len(nbrs[n])
+                )
                 yield (n, deg)
         else:
             for n in self._nodes:
                 nbrs = self._succ[n]
-                deg = sum(d.get(weight, 1) for key_dict in nbrs.values()
-                          for d in key_dict.values())
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in nbrs.values()
+                    for d in key_dict.values()
+                )
                 if n in nbrs:
                     deg += sum(d.get(weight, 1) for d in nbrs[n].values())
                 yield (n, deg)
@@ -530,13 +557,15 @@ class DiMultiDegreeView(DiDegreeView):
         succs = self._succ[n]
         preds = self._pred[n]
         if weight is None:
-            return sum(len(keys) for keys in succs.values()) + \
-                sum(len(keys) for keys in preds.values())
+            return sum(len(keys) for keys in succs.values()) + sum(
+                len(keys) for keys in preds.values()
+            )
         # edge weighted graph - degree is sum of nbr edge weights
-        deg = sum(d.get(weight, 1) for key_dict in succs.values()
-                  for d in key_dict.values()) + \
-            sum(d.get(weight, 1) for key_dict in preds.values()
-                for d in key_dict.values())
+        deg = sum(
+            d.get(weight, 1) for key_dict in succs.values() for d in key_dict.values()
+        ) + sum(
+            d.get(weight, 1) for key_dict in preds.values() for d in key_dict.values()
+        )
         return deg
 
     def __iter__(self):
@@ -545,17 +574,23 @@ class DiMultiDegreeView(DiDegreeView):
             for n in self._nodes:
                 succs = self._succ[n]
                 preds = self._pred[n]
-                deg = sum(len(keys) for keys in succs.values()) + \
-                    sum(len(keys) for keys in preds.values())
+                deg = sum(len(keys) for keys in succs.values()) + sum(
+                    len(keys) for keys in preds.values()
+                )
                 yield (n, deg)
         else:
             for n in self._nodes:
                 succs = self._succ[n]
                 preds = self._pred[n]
-                deg = sum(d.get(weight, 1) for key_dict in succs.values()
-                          for d in key_dict.values()) + \
-                    sum(d.get(weight, 1) for key_dict in preds.values()
-                        for d in key_dict.values())
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in succs.values()
+                    for d in key_dict.values()
+                ) + sum(
+                    d.get(weight, 1)
+                    for key_dict in preds.values()
+                    for d in key_dict.values()
+                )
                 yield (n, deg)
 
 
@@ -568,8 +603,9 @@ class InMultiDegreeView(DiDegreeView):
         if weight is None:
             return sum(len(data) for data in nbrs.values())
         # edge weighted graph - degree is sum of nbr edge weights
-        return sum(d.get(weight, 1) for key_dict in nbrs.values()
-                   for d in key_dict.values())
+        return sum(
+            d.get(weight, 1) for key_dict in nbrs.values() for d in key_dict.values()
+        )
 
     def __iter__(self):
         weight = self._weight
@@ -581,8 +617,11 @@ class InMultiDegreeView(DiDegreeView):
         else:
             for n in self._nodes:
                 nbrs = self._pred[n]
-                deg = sum(d.get(weight, 1) for key_dict in nbrs.values()
-                          for d in key_dict.values())
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in nbrs.values()
+                    for d in key_dict.values()
+                )
                 yield (n, deg)
 
 
@@ -595,8 +634,9 @@ class OutMultiDegreeView(DiDegreeView):
         if weight is None:
             return sum(len(data) for data in nbrs.values())
         # edge weighted graph - degree is sum of nbr edge weights
-        return sum(d.get(weight, 1) for key_dict in nbrs.values()
-                   for d in key_dict.values())
+        return sum(
+            d.get(weight, 1) for key_dict in nbrs.values() for d in key_dict.values()
+        )
 
     def __iter__(self):
         weight = self._weight
@@ -608,22 +648,35 @@ class OutMultiDegreeView(DiDegreeView):
         else:
             for n in self._nodes:
                 nbrs = self._succ[n]
-                deg = sum(d.get(weight, 1) for key_dict in nbrs.values()
-                          for d in key_dict.values())
+                deg = sum(
+                    d.get(weight, 1)
+                    for key_dict in nbrs.values()
+                    for d in key_dict.values()
+                )
                 yield (n, deg)
 
 
 # EdgeDataViews
 class OutEdgeDataView:
     """EdgeDataView for outward edges of DiGraph; See EdgeDataView"""
-    __slots__ = ('_viewer', '_nbunch', '_data', '_default',
-                 '_adjdict', '_nodes_nbrs', '_report')
+
+    __slots__ = (
+        "_viewer",
+        "_nbunch",
+        "_data",
+        "_default",
+        "_adjdict",
+        "_nodes_nbrs",
+        "_report",
+    )
 
     def __getstate__(self):
-        return {'viewer': self._viewer,
-                'nbunch': self._nbunch,
-                'data': self._data,
-                'default': self._default}
+        return {
+            "viewer": self._viewer,
+            "nbunch": self._nbunch,
+            "data": self._data,
+            "default": self._default,
+        }
 
     def __setstate__(self, state):
         self.__init__(**state)
@@ -646,15 +699,21 @@ class OutEdgeDataView:
         elif data is False:
             self._report = lambda n, nbr, dd: (n, nbr)
         else:  # data is attribute name
-            self._report = lambda n, nbr, dd: \
-                (n, nbr, dd[data]) if data in dd else (n, nbr, default)
+            self._report = (
+                lambda n, nbr, dd: (n, nbr, dd[data])
+                if data in dd
+                else (n, nbr, default)
+            )
 
     def __len__(self):
         return sum(len(nbrs) for n, nbrs in self._nodes_nbrs())
 
     def __iter__(self):
-        return (self._report(n, nbr, dd) for n, nbrs in self._nodes_nbrs()
-                for nbr, dd in nbrs.items())
+        return (
+            self._report(n, nbr, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, dd in nbrs.items()
+        )
 
     def __contains__(self, e):
         u, v = e[:2]
@@ -701,6 +760,7 @@ class EdgeDataView(OutEdgeDataView):
     [(0, 1, 'biz'), (1, 2, 'bar')]
     >>> assert((0, 1, 'biz') in G.edges(data='foo', default='biz'))
     """
+
     __slots__ = ()
 
     def __len__(self):
@@ -728,11 +788,15 @@ class EdgeDataView(OutEdgeDataView):
 
 class InEdgeDataView(OutEdgeDataView):
     """An EdgeDataView class for outward edges of DiGraph; See EdgeDataView"""
+
     __slots__ = ()
 
     def __iter__(self):
-        return (self._report(nbr, n, dd) for n, nbrs in self._nodes_nbrs()
-                for nbr, dd in nbrs.items())
+        return (
+            self._report(nbr, n, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, dd in nbrs.items()
+        )
 
     def __contains__(self, e):
         u, v = e[:2]
@@ -745,23 +809,24 @@ class InEdgeDataView(OutEdgeDataView):
         return e == self._report(u, v, ddict)
 
 
-
 class OutMultiEdgeDataView(OutEdgeDataView):
     """An EdgeDataView for outward edges of MultiDiGraph; See EdgeDataView"""
-    __slots__ = ('keys',)
+
+    __slots__ = ("keys",)
 
     def __getstate__(self):
-        return {'viewer': self._viewer,
-                'nbunch': self._nbunch,
-                'keys': self.keys,
-                'data': self._data,
-                'default': self._default}
+        return {
+            "viewer": self._viewer,
+            "nbunch": self._nbunch,
+            "keys": self.keys,
+            "data": self._data,
+            "default": self._default,
+        }
 
     def __setstate__(self, state):
         self.__init__(**state)
 
-    def __init__(self, viewer, nbunch=None,
-                 data=False, keys=False, default=None):
+    def __init__(self, viewer, nbunch=None, data=False, keys=False, default=None):
         self._viewer = viewer
         adjdict = self._adjdict = viewer._adjdict
         self.keys = keys
@@ -787,18 +852,28 @@ class OutMultiEdgeDataView(OutEdgeDataView):
                 self._report = lambda n, nbr, k, dd: (n, nbr)
         else:  # data is attribute name
             if keys is True:
-                self._report = lambda n, nbr, k, dd: (n, nbr, k, dd[data]) \
-                    if data in dd else (n, nbr, k, default)
+                self._report = (
+                    lambda n, nbr, k, dd: (n, nbr, k, dd[data])
+                    if data in dd
+                    else (n, nbr, k, default)
+                )
             else:
-                self._report = lambda n, nbr, k, dd: (n, nbr, dd[data]) \
-                    if data in dd else (n, nbr, default)
+                self._report = (
+                    lambda n, nbr, k, dd: (n, nbr, dd[data])
+                    if data in dd
+                    else (n, nbr, default)
+                )
 
     def __len__(self):
         return sum(1 for e in self)
 
     def __iter__(self):
-        return (self._report(n, nbr, k, dd) for n, nbrs in self._nodes_nbrs()
-                for nbr, kd in nbrs.items() for k, dd in kd.items())
+        return (
+            self._report(n, nbr, k, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, kd in nbrs.items()
+            for k, dd in kd.items()
+        )
 
     def __contains__(self, e):
         u, v = e[:2]
@@ -823,6 +898,7 @@ class OutMultiEdgeDataView(OutEdgeDataView):
 
 class MultiEdgeDataView(OutMultiEdgeDataView):
     """An EdgeDataView class for edges of MultiGraph; See EdgeDataView"""
+
     __slots__ = ()
 
     def __iter__(self):
@@ -861,11 +937,16 @@ class MultiEdgeDataView(OutMultiEdgeDataView):
 
 class InMultiEdgeDataView(OutMultiEdgeDataView):
     """An EdgeDataView for inward edges of MultiDiGraph; See EdgeDataView"""
+
     __slots__ = ()
 
     def __iter__(self):
-        return (self._report(nbr, n, k, dd) for n, nbrs in self._nodes_nbrs()
-                for nbr, kd in nbrs.items() for k, dd in kd.items())
+        return (
+            self._report(nbr, n, k, dd)
+            for n, nbrs in self._nodes_nbrs()
+            for nbr, kd in nbrs.items()
+            for k, dd in kd.items()
+        )
 
     def __contains__(self, e):
         u, v = e[:2]
@@ -888,13 +969,14 @@ class InMultiEdgeDataView(OutMultiEdgeDataView):
 # EdgeViews    have set operations and no data reported
 class OutEdgeView(Set, Mapping):
     """A EdgeView class for outward edges of a DiGraph"""
-    __slots__ = ('_adjdict', '_graph', '_nodes_nbrs')
+
+    __slots__ = ("_adjdict", "_graph", "_nodes_nbrs")
 
     def __getstate__(self):
-        return {'_graph': self._graph}
+        return {"_graph": self._graph}
 
     def __setstate__(self, state):
-        self._graph = G = state['_graph']
+        self._graph = G = state["_graph"]
         self._adjdict = G._succ if hasattr(G, "succ") else G._adj
         self._nodes_nbrs = self._adjdict.items
 
@@ -1015,6 +1097,7 @@ class EdgeView(OutEdgeView):
     (2, 3, 0)
     (2, 3, 1)
     """
+
     __slots__ = ()
 
     dataview = EdgeDataView
@@ -1042,10 +1125,11 @@ class EdgeView(OutEdgeView):
 
 class InEdgeView(OutEdgeView):
     """A EdgeView class for inward edges of a DiGraph"""
+
     __slots__ = ()
 
     def __setstate__(self, state):
-        self._graph = G = state['_graph']
+        self._graph = G = state["_graph"]
         self._adjdict = G._pred if hasattr(G, "pred") else G._adj
         self._nodes_nbrs = self._adjdict.items
 
@@ -1075,13 +1159,15 @@ class InEdgeView(OutEdgeView):
 
 class OutMultiEdgeView(OutEdgeView):
     """A EdgeView class for outward edges of a MultiDiGraph"""
+
     __slots__ = ()
 
     dataview = OutMultiEdgeDataView
 
     def __len__(self):
-        return sum(len(kdict) for n, nbrs in self._nodes_nbrs()
-                   for nbr, kdict in nbrs.items())
+        return sum(
+            len(kdict) for n, nbrs in self._nodes_nbrs() for nbr, kdict in nbrs.items()
+        )
 
     def __iter__(self):
         for n, nbrs in self._nodes_nbrs():
@@ -1120,6 +1206,7 @@ class OutMultiEdgeView(OutEdgeView):
 
 class MultiEdgeView(OutMultiEdgeView):
     """A EdgeView class for edges of a MultiGraph"""
+
     __slots__ = ()
 
     dataview = MultiEdgeDataView
@@ -1140,10 +1227,11 @@ class MultiEdgeView(OutMultiEdgeView):
 
 class InMultiEdgeView(OutMultiEdgeView):
     """A EdgeView class for inward edges of a MultiDiGraph"""
+
     __slots__ = ()
 
     def __setstate__(self, state):
-        self._graph = G = state['_graph']
+        self._graph = G = state["_graph"]
         self._adjdict = G._pred if hasattr(G, "pred") else G._adj
         self._nodes_nbrs = self._adjdict.items
 
diff --git a/networkx/classes/tests/historical_tests.py b/networkx/classes/tests/historical_tests.py
index 85e69f4d..8f53c4c5 100644
--- a/networkx/classes/tests/historical_tests.py
+++ b/networkx/classes/tests/historical_tests.py
@@ -6,7 +6,6 @@ from networkx.testing import assert_edges_equal, assert_nodes_equal
 
 
 class HistoricalTests:
-
     @classmethod
     def setup_class(cls):
         cls.null = nx.null_graph()
@@ -22,19 +21,19 @@ class HistoricalTests:
 
     def test_name(self):
         G = self.G(name="test")
-        assert str(G) == 'test'
-        assert G.name == 'test'
+        assert str(G) == "test"
+        assert G.name == "test"
         H = self.G()
-        assert H.name == ''
+        assert H.name == ""
 
     # Nodes
 
     def test_add_remove_node(self):
         G = self.G()
-        G.add_node('A')
-        assert G.has_node('A')
-        G.remove_node('A')
-        assert not G.has_node('A')
+        G.add_node("A")
+        assert G.has_node("A")
+        G.remove_node("A")
+        assert not G.has_node("A")
 
     def test_nonhashable_node(self):
         # Test if a non-hashable object is in the Graph.  A python dict will
@@ -42,47 +41,55 @@ class HistoricalTests:
         # returned (see Graph __contains__). If it cannot be a node then it is
         # not a node.
         G = self.G()
-        assert not G.has_node(['A'])
-        assert not G.has_node({'A': 1})
+        assert not G.has_node(["A"])
+        assert not G.has_node({"A": 1})
 
     def test_add_nodes_from(self):
         G = self.G()
         G.add_nodes_from(list("ABCDEFGHIJKL"))
         assert G.has_node("L")
-        G.remove_nodes_from(['H', 'I', 'J', 'K', 'L'])
+        G.remove_nodes_from(["H", "I", "J", "K", "L"])
         G.add_nodes_from([1, 2, 3, 4])
-        assert (sorted(G.nodes(), key=str) ==
-                [1, 2, 3, 4, 'A', 'B', 'C', 'D', 'E', 'F', 'G'])
+        assert sorted(G.nodes(), key=str) == [
+            1,
+            2,
+            3,
+            4,
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+        ]
         # test __iter__
-        assert (sorted(G, key=str) ==
-                [1, 2, 3, 4, 'A', 'B', 'C', 'D', 'E', 'F', 'G'])
+        assert sorted(G, key=str) == [1, 2, 3, 4, "A", "B", "C", "D", "E", "F", "G"]
 
     def test_contains(self):
         G = self.G()
-        G.add_node('A')
-        assert 'A' in G
+        G.add_node("A")
+        assert "A" in G
         assert not [] in G  # never raise a Key or TypeError in this test
         assert not {1: 1} in G
 
     def test_add_remove(self):
         # Test add_node and remove_node acting for various nbunch
         G = self.G()
-        G.add_node('m')
-        assert G.has_node('m')
-        G.add_node('m')   # no complaints
-        pytest.raises(nx.NetworkXError, G.remove_node, 'j')
-        G.remove_node('m')
+        G.add_node("m")
+        assert G.has_node("m")
+        G.add_node("m")  # no complaints
+        pytest.raises(nx.NetworkXError, G.remove_node, "j")
+        G.remove_node("m")
         assert list(G) == []
 
     def test_nbunch_is_list(self):
         G = self.G()
         G.add_nodes_from(list("ABCD"))
         G.add_nodes_from(self.P3)  # add nbunch of nodes (nbunch=Graph)
-        assert (sorted(G.nodes(), key=str) ==
-                [1, 2, 3, 'A', 'B', 'C', 'D'])
+        assert sorted(G.nodes(), key=str) == [1, 2, 3, "A", "B", "C", "D"]
         G.remove_nodes_from(self.P3)  # remove nbunch of nodes (nbunch=Graph)
-        assert (sorted(G.nodes(), key=str) ==
-                ['A', 'B', 'C', 'D'])
+        assert sorted(G.nodes(), key=str) == ["A", "B", "C", "D"]
 
     def test_nbunch_is_set(self):
         G = self.G()
@@ -95,172 +102,191 @@ class HistoricalTests:
         G = self.G()
         nbunch = set("ABCDEFGHIJKL")
         G.add_nodes_from(nbunch)
-        nbunch = {'I': "foo", 'J': 2, 'K': True, 'L': "spam"}
+        nbunch = {"I": "foo", "J": 2, "K": True, "L": "spam"}
         G.remove_nodes_from(nbunch)
-        assert sorted(G.nodes(), key=str), ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
+        assert sorted(G.nodes(), key=str), ["A", "B", "C", "D", "E", "F", "G", "H"]
 
     def test_nbunch_iterator(self):
         G = self.G()
-        G.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'])
+        G.add_nodes_from(["A", "B", "C", "D", "E", "F", "G", "H"])
         n_iter = self.P3.nodes()
         G.add_nodes_from(n_iter)
-        assert (sorted(G.nodes(), key=str) ==
-                [1, 2, 3, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'])
+        assert sorted(G.nodes(), key=str) == [
+            1,
+            2,
+            3,
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+            "H",
+        ]
         n_iter = self.P3.nodes()  # rebuild same iterator
         G.remove_nodes_from(n_iter)  # remove nbunch of nodes (nbunch=iterator)
-        assert (sorted(G.nodes(), key=str) ==
-                ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'])
+        assert sorted(G.nodes(), key=str) == ["A", "B", "C", "D", "E", "F", "G", "H"]
 
     def test_nbunch_graph(self):
         G = self.G()
-        G.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'])
+        G.add_nodes_from(["A", "B", "C", "D", "E", "F", "G", "H"])
         nbunch = self.K3
         G.add_nodes_from(nbunch)
-        assert sorted(G.nodes(), key=str), [1, 2, 3, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
+        assert sorted(G.nodes(), key=str), [
+            1,
+            2,
+            3,
+            "A",
+            "B",
+            "C",
+            "D",
+            "E",
+            "F",
+            "G",
+            "H",
+        ]
 
     # Edges
 
     def test_add_edge(self):
         G = self.G()
-        pytest.raises(TypeError, G.add_edge, 'A')
+        pytest.raises(TypeError, G.add_edge, "A")
 
-        G.add_edge('A', 'B')     # testing add_edge()
-        G.add_edge('A', 'B')  # should fail silently
-        assert G.has_edge('A', 'B')
-        assert not G.has_edge('A', 'C')
-        assert G.has_edge(*('A', 'B'))
+        G.add_edge("A", "B")  # testing add_edge()
+        G.add_edge("A", "B")  # should fail silently
+        assert G.has_edge("A", "B")
+        assert not G.has_edge("A", "C")
+        assert G.has_edge(*("A", "B"))
         if G.is_directed():
-            assert not G.has_edge('B', 'A')
+            assert not G.has_edge("B", "A")
         else:
             # G is undirected, so B->A is an edge
-            assert G.has_edge('B', 'A')
+            assert G.has_edge("B", "A")
 
-        G.add_edge('A', 'C')  # test directedness
-        G.add_edge('C', 'A')
-        G.remove_edge('C', 'A')
+        G.add_edge("A", "C")  # test directedness
+        G.add_edge("C", "A")
+        G.remove_edge("C", "A")
         if G.is_directed():
-            assert G.has_edge('A', 'C')
+            assert G.has_edge("A", "C")
         else:
-            assert not G.has_edge('A', 'C')
-        assert not G.has_edge('C', 'A')
+            assert not G.has_edge("A", "C")
+        assert not G.has_edge("C", "A")
 
     def test_self_loop(self):
         G = self.G()
-        G.add_edge('A', 'A')  # test self loops
-        assert G.has_edge('A', 'A')
-        G.remove_edge('A', 'A')
-        G.add_edge('X', 'X')
-        assert G.has_node('X')
-        G.remove_node('X')
-        G.add_edge('A', 'Z')  # should add the node silently
-        assert G.has_node('Z')
+        G.add_edge("A", "A")  # test self loops
+        assert G.has_edge("A", "A")
+        G.remove_edge("A", "A")
+        G.add_edge("X", "X")
+        assert G.has_node("X")
+        G.remove_node("X")
+        G.add_edge("A", "Z")  # should add the node silently
+        assert G.has_node("Z")
 
     def test_add_edges_from(self):
         G = self.G()
-        G.add_edges_from([('B', 'C')])   # test add_edges_from()
-        assert G.has_edge('B', 'C')
+        G.add_edges_from([("B", "C")])  # test add_edges_from()
+        assert G.has_edge("B", "C")
         if G.is_directed():
-            assert not G.has_edge('C', 'B')
+            assert not G.has_edge("C", "B")
         else:
-            assert G.has_edge('C', 'B')  # undirected
+            assert G.has_edge("C", "B")  # undirected
 
-        G.add_edges_from([('D', 'F'), ('B', 'D')])
-        assert G.has_edge('D', 'F')
-        assert G.has_edge('B', 'D')
+        G.add_edges_from([("D", "F"), ("B", "D")])
+        assert G.has_edge("D", "F")
+        assert G.has_edge("B", "D")
 
         if G.is_directed():
-            assert not G.has_edge('D', 'B')
+            assert not G.has_edge("D", "B")
         else:
-            assert G.has_edge('D', 'B')  # undirected
+            assert G.has_edge("D", "B")  # undirected
 
     def test_add_edges_from2(self):
         G = self.G()
         # after failing silently, should add 2nd edge
-        G.add_edges_from([tuple('IJ'), list('KK'), tuple('JK')])
-        assert G.has_edge(*('I', 'J'))
-        assert G.has_edge(*('K', 'K'))
-        assert G.has_edge(*('J', 'K'))
+        G.add_edges_from([tuple("IJ"), list("KK"), tuple("JK")])
+        assert G.has_edge(*("I", "J"))
+        assert G.has_edge(*("K", "K"))
+        assert G.has_edge(*("J", "K"))
         if G.is_directed():
-            assert not G.has_edge(*('K', 'J'))
+            assert not G.has_edge(*("K", "J"))
         else:
-            assert G.has_edge(*('K', 'J'))
+            assert G.has_edge(*("K", "J"))
 
     def test_add_edges_from3(self):
         G = self.G()
-        G.add_edges_from(zip(list('ACD'), list('CDE')))
-        assert G.has_edge('D', 'E')
-        assert not G.has_edge('E', 'C')
+        G.add_edges_from(zip(list("ACD"), list("CDE")))
+        assert G.has_edge("D", "E")
+        assert not G.has_edge("E", "C")
 
     def test_remove_edge(self):
         G = self.G()
-        G.add_nodes_from([1, 2, 3, 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'])
+        G.add_nodes_from([1, 2, 3, "A", "B", "C", "D", "E", "F", "G", "H"])
 
-        G.add_edges_from(zip(list('MNOP'), list('NOPM')))
-        assert G.has_edge('O', 'P')
-        assert G.has_edge('P', 'M')
-        G.remove_node('P')    # tests remove_node()'s handling of edges.
-        assert not G.has_edge('P', 'M')
-        pytest.raises(TypeError, G.remove_edge, 'M')
+        G.add_edges_from(zip(list("MNOP"), list("NOPM")))
+        assert G.has_edge("O", "P")
+        assert G.has_edge("P", "M")
+        G.remove_node("P")  # tests remove_node()'s handling of edges.
+        assert not G.has_edge("P", "M")
+        pytest.raises(TypeError, G.remove_edge, "M")
 
-        G.add_edge('N', 'M')
-        assert G.has_edge('M', 'N')
-        G.remove_edge('M', 'N')
-        assert not G.has_edge('M', 'N')
+        G.add_edge("N", "M")
+        assert G.has_edge("M", "N")
+        G.remove_edge("M", "N")
+        assert not G.has_edge("M", "N")
 
         # self loop fails silently
-        G.remove_edges_from([list('HI'), list('DF'),
-                             tuple('KK'), tuple('JK')])
-        assert not G.has_edge('H', 'I')
-        assert not G.has_edge('J', 'K')
-        G.remove_edges_from([list('IJ'), list('KK'), list('JK')])
-        assert not G.has_edge('I', 'J')
-        G.remove_nodes_from(set('ZEFHIMNO'))
-        G.add_edge('J', 'K')
+        G.remove_edges_from([list("HI"), list("DF"), tuple("KK"), tuple("JK")])
+        assert not G.has_edge("H", "I")
+        assert not G.has_edge("J", "K")
+        G.remove_edges_from([list("IJ"), list("KK"), list("JK")])
+        assert not G.has_edge("I", "J")
+        G.remove_nodes_from(set("ZEFHIMNO"))
+        G.add_edge("J", "K")
 
     def test_edges_nbunch(self):
         # Test G.edges(nbunch) with various forms of nbunch
         G = self.G()
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('C', 'B'), ('C', 'D')])
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
         # node not in nbunch should be quietly ignored
         pytest.raises(nx.NetworkXError, G.edges, 6)
-        assert list(G.edges('Z')) == []  # iterable non-node
+        assert list(G.edges("Z")) == []  # iterable non-node
         # nbunch can be an empty list
         assert list(G.edges([])) == []
         if G.is_directed():
-            elist = [('A', 'B'), ('A', 'C'), ('B', 'D')]
+            elist = [("A", "B"), ("A", "C"), ("B", "D")]
         else:
-            elist = [('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D')]
+            elist = [("A", "B"), ("A", "C"), ("B", "C"), ("B", "D")]
         # nbunch can be a list
-        assert_edges_equal(list(G.edges(['A', 'B'])), elist)
+        assert_edges_equal(list(G.edges(["A", "B"])), elist)
         # nbunch can be a set
-        assert_edges_equal(G.edges({'A', 'B'}), elist)
+        assert_edges_equal(G.edges({"A", "B"}), elist)
         # nbunch can be a graph
         G1 = self.G()
-        G1.add_nodes_from('AB')
+        G1.add_nodes_from("AB")
         assert_edges_equal(G.edges(G1), elist)
         # nbunch can be a dict with nodes as keys
-        ndict = {'A': "thing1", 'B': "thing2"}
+        ndict = {"A": "thing1", "B": "thing2"}
         assert_edges_equal(G.edges(ndict), elist)
         # nbunch can be a single node
-        assert_edges_equal(list(G.edges('A')), [('A', 'B'), ('A', 'C')])
-        assert_nodes_equal(sorted(G), ['A', 'B', 'C', 'D'])
+        assert_edges_equal(list(G.edges("A")), [("A", "B"), ("A", "C")])
+        assert_nodes_equal(sorted(G), ["A", "B", "C", "D"])
 
         # nbunch can be nothing (whole graph)
         assert_edges_equal(
             list(G.edges()),
-            [('A', 'B'), ('A', 'C'), ('B', 'D'), ('C', 'B'), ('C', 'D')]
+            [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")],
         )
 
     def test_degree(self):
         G = self.G()
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('C', 'B'), ('C', 'D')])
-        assert G.degree('A') == 2
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        assert G.degree("A") == 2
 
         # degree of single node in iterable container must return dict
-        assert list(G.degree(['A'])) == [('A', 2)]
-        assert sorted(d for n, d in G.degree(['A', 'B'])) == [2, 3]
+        assert list(G.degree(["A"])) == [("A", 2)]
+        assert sorted(d for n, d in G.degree(["A", "B"])) == [2, 3]
         assert sorted(d for n, d in G.degree()) == [2, 2, 3, 3]
 
     def test_degree2(self):
@@ -272,7 +298,7 @@ class HistoricalTests:
         P3 = nx.path_graph(3)
         P5 = nx.path_graph(5)
         # silently ignore nodes not in P3
-        assert dict(d for n, d in P3.degree(['A', 'B'])) == {}
+        assert dict(d for n, d in P3.degree(["A", "B"])) == {}
         # nbunch can be a graph
         assert sorted(d for n, d in P5.degree(P3)) == [1, 2, 2]
         # nbunch can be a graph that's way too big
@@ -287,34 +313,33 @@ class HistoricalTests:
 
     def test_order_size(self):
         G = self.G()
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('C', 'B'), ('C', 'D')])
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
         assert G.order() == 4
         assert G.size() == 5
         assert G.number_of_edges() == 5
-        assert G.number_of_edges('A', 'B') == 1
-        assert G.number_of_edges('A', 'D') == 0
+        assert G.number_of_edges("A", "B") == 1
+        assert G.number_of_edges("A", "D") == 0
 
     def test_copy(self):
         G = self.G()
-        H = G.copy()      # copy
+        H = G.copy()  # copy
         assert H.adj == G.adj
         assert H.name == G.name
         assert H != G
 
     def test_subgraph(self):
         G = self.G()
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('C', 'B'), ('C', 'D')])
-        SG = G.subgraph(['A', 'B', 'D'])
-        assert_nodes_equal(list(SG), ['A', 'B', 'D'])
-        assert_edges_equal(list(SG.edges()), [('A', 'B'), ('B', 'D')])
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        SG = G.subgraph(["A", "B", "D"])
+        assert_nodes_equal(list(SG), ["A", "B", "D"])
+        assert_edges_equal(list(SG.edges()), [("A", "B"), ("B", "D")])
 
     def test_to_directed(self):
         G = self.G()
         if not G.is_directed():
-            G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                              ('C', 'B'), ('C', 'D')])
+            G.add_edges_from(
+                [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]
+            )
 
             DG = G.to_directed()
             assert DG != G  # directed copy or copy
@@ -322,60 +347,76 @@ class HistoricalTests:
             assert DG.is_directed()
             assert DG.name == G.name
             assert DG.adj == G.adj
-            assert (sorted(DG.out_edges(list('AB'))) ==
-                    [('A', 'B'), ('A', 'C'), ('B', 'A'),
-                     ('B', 'C'), ('B', 'D')])
-            DG.remove_edge('A', 'B')
-            assert DG.has_edge('B', 'A')  # this removes B-A but not  A-B
-            assert not DG.has_edge('A', 'B')
+            assert sorted(DG.out_edges(list("AB"))) == [
+                ("A", "B"),
+                ("A", "C"),
+                ("B", "A"),
+                ("B", "C"),
+                ("B", "D"),
+            ]
+            DG.remove_edge("A", "B")
+            assert DG.has_edge("B", "A")  # this removes B-A but not  A-B
+            assert not DG.has_edge("A", "B")
 
     def test_to_undirected(self):
         G = self.G()
         if G.is_directed():
-            G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                              ('C', 'B'), ('C', 'D')])
-            UG = G.to_undirected()       # to_undirected
+            G.add_edges_from(
+                [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]
+            )
+            UG = G.to_undirected()  # to_undirected
             assert UG != G
             assert not UG.is_directed()
             assert G.is_directed()
             assert UG.name == G.name
             assert UG.adj != G.adj
-            assert (sorted(UG.edges(list('AB'))) ==
-                    [('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D')])
-            assert (sorted(UG.edges(['A', 'B'])) ==
-                    [('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D')])
-            UG.remove_edge('A', 'B')
-            assert not UG.has_edge('B', 'A')
-            assert not UG.has_edge('A', 'B')
+            assert sorted(UG.edges(list("AB"))) == [
+                ("A", "B"),
+                ("A", "C"),
+                ("B", "C"),
+                ("B", "D"),
+            ]
+            assert sorted(UG.edges(["A", "B"])) == [
+                ("A", "B"),
+                ("A", "C"),
+                ("B", "C"),
+                ("B", "D"),
+            ]
+            UG.remove_edge("A", "B")
+            assert not UG.has_edge("B", "A")
+            assert not UG.has_edge("A", "B")
 
     def test_neighbors(self):
         G = self.G()
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('C', 'B'), ('C', 'D')])
-        G.add_nodes_from('GJK')
-        assert sorted(G['A']) == ['B', 'C']
-        assert sorted(G.neighbors('A')) == ['B', 'C']
-        assert sorted(G.neighbors('A')) == ['B', 'C']
-        assert sorted(G.neighbors('G')) == []
-        pytest.raises(nx.NetworkXError, G.neighbors, 'j')
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        G.add_nodes_from("GJK")
+        assert sorted(G["A"]) == ["B", "C"]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        assert sorted(G.neighbors("G")) == []
+        pytest.raises(nx.NetworkXError, G.neighbors, "j")
 
     def test_iterators(self):
         G = self.G()
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('C', 'B'), ('C', 'D')])
-        G.add_nodes_from('GJK')
-        assert (sorted(G.nodes()) ==
-                ['A', 'B', 'C', 'D', 'G', 'J', 'K'])
-        assert_edges_equal(G.edges(),
-                           [('A', 'B'), ('A', 'C'), ('B', 'D'), ('C', 'B'), ('C', 'D')])
-
-        assert (sorted([v for k, v in G.degree()]) ==
-                [0, 0, 0, 2, 2, 3, 3])
-        assert (sorted(G.degree(), key=str) ==
-                [('A', 2), ('B', 3), ('C', 3), ('D', 2),
-                 ('G', 0), ('J', 0), ('K', 0)])
-        assert sorted(G.neighbors('A')) == ['B', 'C']
-        pytest.raises(nx.NetworkXError, G.neighbors, 'X')
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")])
+        G.add_nodes_from("GJK")
+        assert sorted(G.nodes()) == ["A", "B", "C", "D", "G", "J", "K"]
+        assert_edges_equal(
+            G.edges(), [("A", "B"), ("A", "C"), ("B", "D"), ("C", "B"), ("C", "D")]
+        )
+
+        assert sorted([v for k, v in G.degree()]) == [0, 0, 0, 2, 2, 3, 3]
+        assert sorted(G.degree(), key=str) == [
+            ("A", 2),
+            ("B", 3),
+            ("C", 3),
+            ("D", 2),
+            ("G", 0),
+            ("J", 0),
+            ("K", 0),
+        ]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        pytest.raises(nx.NetworkXError, G.neighbors, "X")
         G.clear()
         assert nx.number_of_nodes(G) == 0
         assert nx.number_of_edges(G) == 0
diff --git a/networkx/classes/tests/test_coreviews.py b/networkx/classes/tests/test_coreviews.py
index 5cad6836..c9b259a0 100644
--- a/networkx/classes/tests/test_coreviews.py
+++ b/networkx/classes/tests/test_coreviews.py
@@ -7,7 +7,7 @@ import networkx as nx
 class TestAtlasView:
     # node->data
     def setup(self):
-        self.d = {0: {'color': 'blue', 'weight': 1.2}, 1: {}, 2: {'color': 1}}
+        self.d = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
         self.av = nx.classes.coreviews.AtlasView(self.d)
 
     def test_pickle(self):
@@ -27,7 +27,7 @@ class TestAtlasView:
 
     def test_getitem(self):
         assert self.av[1] is self.d[1]
-        assert self.av[2]['color'] == 1
+        assert self.av[2]["color"] == 1
         pytest.raises(KeyError, self.av.__getitem__, 3)
 
     def test_copy(self):
@@ -39,13 +39,13 @@ class TestAtlasView:
         avcopy[5] = {}
         assert avcopy != self.av
 
-        avcopy[0]['ht'] = 4
+        avcopy[0]["ht"] = 4
         assert avcopy[0] != self.av[0]
-        self.av[0]['ht'] = 4
+        self.av[0]["ht"] = 4
         assert avcopy[0] == self.av[0]
-        del self.av[0]['ht']
+        del self.av[0]["ht"]
 
-        assert not hasattr(self.av, '__setitem__')
+        assert not hasattr(self.av, "__setitem__")
 
     def test_items(self):
         assert sorted(self.av.items()) == sorted(self.d.items())
@@ -62,9 +62,9 @@ class TestAtlasView:
 class TestAdjacencyView:
     # node->nbr->data
     def setup(self):
-        dd = {'color': 'blue', 'weight': 1.2}
-        self.nd = {0: dd, 1: {}, 2: {'color': 1}}
-        self.adj = {3: self.nd, 0: {3: dd}, 1: {}, 2: {3: {'color': 1}}}
+        dd = {"color": "blue", "weight": 1.2}
+        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.adj = {3: self.nd, 0: {3: dd}, 1: {}, 2: {3: {"color": 1}}}
         self.adjview = nx.classes.coreviews.AdjacencyView(self.adj)
 
     def test_pickle(self):
@@ -82,7 +82,7 @@ class TestAdjacencyView:
     def test_getitem(self):
         assert self.adjview[1] is not self.adj[1]
         assert self.adjview[3][0] is self.adjview[0][3]
-        assert self.adjview[2][3]['color'] == 1
+        assert self.adjview[2][3]["color"] == 1
         pytest.raises(KeyError, self.adjview.__getitem__, 4)
 
     def test_copy(self):
@@ -90,13 +90,13 @@ class TestAdjacencyView:
         assert avcopy[0] == self.adjview[0]
         assert avcopy[0] is not self.adjview[0]
 
-        avcopy[2][3]['ht'] = 4
+        avcopy[2][3]["ht"] = 4
         assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3]['ht'] = 4
+        self.adjview[2][3]["ht"] = 4
         assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3]['ht']
+        del self.adjview[2][3]["ht"]
 
-        assert not hasattr(self.adjview, '__setitem__')
+        assert not hasattr(self.adjview, "__setitem__")
 
     def test_items(self):
         view_items = sorted((n, dict(d)) for n, d in self.adjview.items())
@@ -114,16 +114,16 @@ class TestAdjacencyView:
 class TestMultiAdjacencyView(TestAdjacencyView):
     # node->nbr->key->data
     def setup(self):
-        dd = {'color': 'blue', 'weight': 1.2}
-        self.kd = {0: dd, 1: {}, 2: {'color': 1}}
-        self.nd = {3: self.kd, 0: {3: dd}, 1: {0: {}}, 2: {3: {'color': 1}}}
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.nd = {3: self.kd, 0: {3: dd}, 1: {0: {}}, 2: {3: {"color": 1}}}
         self.adj = {3: self.nd, 0: {3: {3: dd}}, 1: {}, 2: {3: {8: {}}}}
         self.adjview = nx.classes.coreviews.MultiAdjacencyView(self.adj)
 
     def test_getitem(self):
         assert self.adjview[1] is not self.adj[1]
         assert self.adjview[3][0][3] is self.adjview[0][3][3]
-        assert self.adjview[3][2][3]['color'] == 1
+        assert self.adjview[3][2][3]["color"] == 1
         pytest.raises(KeyError, self.adjview.__getitem__, 4)
 
     def test_copy(self):
@@ -131,20 +131,20 @@ class TestMultiAdjacencyView(TestAdjacencyView):
         assert avcopy[0] == self.adjview[0]
         assert avcopy[0] is not self.adjview[0]
 
-        avcopy[2][3][8]['ht'] = 4
+        avcopy[2][3][8]["ht"] = 4
         assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3][8]['ht'] = 4
+        self.adjview[2][3][8]["ht"] = 4
         assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3][8]['ht']
+        del self.adjview[2][3][8]["ht"]
 
-        assert not hasattr(self.adjview, '__setitem__')
+        assert not hasattr(self.adjview, "__setitem__")
 
 
 class TestUnionAtlas:
     # node->data
     def setup(self):
-        self.s = {0: {'color': 'blue', 'weight': 1.2}, 1: {}, 2: {'color': 1}}
-        self.p = {3: {'color': 'blue', 'weight': 1.2}, 4: {}, 2: {'watch': 2}}
+        self.s = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
+        self.p = {3: {"color": "blue", "weight": 1.2}, 4: {}, 2: {"watch": 2}}
         self.av = nx.classes.coreviews.UnionAtlas(self.s, self.p)
 
     def test_pickle(self):
@@ -162,8 +162,8 @@ class TestUnionAtlas:
     def test_getitem(self):
         assert self.av[0] is self.s[0]
         assert self.av[4] is self.p[4]
-        assert self.av[2]['color'] == 1
-        pytest.raises(KeyError, self.av[2].__getitem__, 'watch')
+        assert self.av[2]["color"] == 1
+        pytest.raises(KeyError, self.av[2].__getitem__, "watch")
         pytest.raises(KeyError, self.av.__getitem__, 8)
 
     def test_copy(self):
@@ -174,13 +174,13 @@ class TestUnionAtlas:
         avcopy[5] = {}
         assert avcopy != self.av
 
-        avcopy[0]['ht'] = 4
+        avcopy[0]["ht"] = 4
         assert avcopy[0] != self.av[0]
-        self.av[0]['ht'] = 4
+        self.av[0]["ht"] = 4
         assert avcopy[0] == self.av[0]
-        del self.av[0]['ht']
+        del self.av[0]["ht"]
 
-        assert not hasattr(self.av, '__setitem__')
+        assert not hasattr(self.av, "__setitem__")
 
     def test_items(self):
         expected = dict(self.p.items())
@@ -199,10 +199,10 @@ class TestUnionAtlas:
 class TestUnionAdjacency:
     # node->nbr->data
     def setup(self):
-        dd = {'color': 'blue', 'weight': 1.2}
-        self.nd = {0: dd, 1: {}, 2: {'color': 1}}
-        self.s = {3: self.nd, 0: {}, 1: {}, 2: {3: {'color': 1}}}
-        self.p = {3: {}, 0: {3: dd}, 1: {0: {}}, 2: {1: {'color': 1}}}
+        dd = {"color": "blue", "weight": 1.2}
+        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.s = {3: self.nd, 0: {}, 1: {}, 2: {3: {"color": 1}}}
+        self.p = {3: {}, 0: {3: dd}, 1: {0: {}}, 2: {1: {"color": 1}}}
         self.adjview = nx.classes.coreviews.UnionAdjacency(self.s, self.p)
 
     def test_pickle(self):
@@ -220,7 +220,7 @@ class TestUnionAdjacency:
     def test_getitem(self):
         assert self.adjview[1] is not self.s[1]
         assert self.adjview[3][0] is self.adjview[0][3]
-        assert self.adjview[2][3]['color'] == 1
+        assert self.adjview[2][3]["color"] == 1
         pytest.raises(KeyError, self.adjview.__getitem__, 4)
 
     def test_copy(self):
@@ -228,13 +228,13 @@ class TestUnionAdjacency:
         assert avcopy[0] == self.adjview[0]
         assert avcopy[0] is not self.adjview[0]
 
-        avcopy[2][3]['ht'] = 4
+        avcopy[2][3]["ht"] = 4
         assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3]['ht'] = 4
+        self.adjview[2][3]["ht"] = 4
         assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3]['ht']
+        del self.adjview[2][3]["ht"]
 
-        assert not hasattr(self.adjview, '__setitem__')
+        assert not hasattr(self.adjview, "__setitem__")
 
     def test_str(self):
         out = str(dict(self.adjview))
@@ -249,10 +249,10 @@ class TestUnionAdjacency:
 class TestUnionMultiInner(TestUnionAdjacency):
     # nbr->key->data
     def setup(self):
-        dd = {'color': 'blue', 'weight': 1.2}
-        self.kd = {7: {}, 'ekey': {}, 9: {'color': 1}}
-        self.s = {3: self.kd, 0: {7: dd}, 1: {}, 2: {'key': {'color': 1}}}
-        self.p = {3: {}, 0: {3: dd}, 1: {}, 2: {1: {'span': 2}}}
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {7: {}, "ekey": {}, 9: {"color": 1}}
+        self.s = {3: self.kd, 0: {7: dd}, 1: {}, 2: {"key": {"color": 1}}}
+        self.p = {3: {}, 0: {3: dd}, 1: {}, 2: {1: {"span": 2}}}
         self.adjview = nx.classes.coreviews.UnionMultiInner(self.s, self.p)
 
     def test_len(self):
@@ -261,32 +261,32 @@ class TestUnionMultiInner(TestUnionAdjacency):
     def test_getitem(self):
         assert self.adjview[1] is not self.s[1]
         assert self.adjview[0][7] is self.adjview[0][3]
-        assert self.adjview[2]['key']['color'] == 1
-        assert self.adjview[2][1]['span'] == 2
+        assert self.adjview[2]["key"]["color"] == 1
+        assert self.adjview[2][1]["span"] == 2
         pytest.raises(KeyError, self.adjview.__getitem__, 4)
-        pytest.raises(KeyError, self.adjview[1].__getitem__, 'key')
+        pytest.raises(KeyError, self.adjview[1].__getitem__, "key")
 
     def test_copy(self):
         avcopy = self.adjview.copy()
         assert avcopy[0] == self.adjview[0]
         assert avcopy[0] is not self.adjview[0]
 
-        avcopy[2][1]['width'] = 8
+        avcopy[2][1]["width"] = 8
         assert avcopy[2] != self.adjview[2]
-        self.adjview[2][1]['width'] = 8
+        self.adjview[2][1]["width"] = 8
         assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][1]['width']
+        del self.adjview[2][1]["width"]
 
-        assert not hasattr(self.adjview, '__setitem__')
-        assert hasattr(avcopy, '__setitem__')
+        assert not hasattr(self.adjview, "__setitem__")
+        assert hasattr(avcopy, "__setitem__")
 
 
 class TestUnionMultiAdjacency(TestUnionAdjacency):
     # node->nbr->key->data
     def setup(self):
-        dd = {'color': 'blue', 'weight': 1.2}
-        self.kd = {7: {}, 8: {}, 9: {'color': 1}}
-        self.nd = {3: self.kd, 0: {9: dd}, 1: {8: {}}, 2: {9: {'color': 1}}}
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {7: {}, 8: {}, 9: {"color": 1}}
+        self.nd = {3: self.kd, 0: {9: dd}, 1: {8: {}}, 2: {9: {"color": 1}}}
         self.s = {3: self.nd, 0: {3: {7: dd}}, 1: {}, 2: {3: {8: {}}}}
         self.p = {3: {}, 0: {3: {9: dd}}, 1: {}, 2: {1: {8: {}}}}
         self.adjview = nx.classes.coreviews.UnionMultiAdjacency(self.s, self.p)
@@ -294,7 +294,7 @@ class TestUnionMultiAdjacency(TestUnionAdjacency):
     def test_getitem(self):
         assert self.adjview[1] is not self.s[1]
         assert self.adjview[3][0][9] is self.adjview[0][3][9]
-        assert self.adjview[3][2][9]['color'] == 1
+        assert self.adjview[3][2][9]["color"] == 1
         pytest.raises(KeyError, self.adjview.__getitem__, 4)
 
     def test_copy(self):
@@ -302,22 +302,19 @@ class TestUnionMultiAdjacency(TestUnionAdjacency):
         assert avcopy[0] == self.adjview[0]
         assert avcopy[0] is not self.adjview[0]
 
-        avcopy[2][3][8]['ht'] = 4
+        avcopy[2][3][8]["ht"] = 4
         assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3][8]['ht'] = 4
+        self.adjview[2][3][8]["ht"] = 4
         assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3][8]['ht']
+        del self.adjview[2][3][8]["ht"]
 
-        assert not hasattr(self.adjview, '__setitem__')
-        assert hasattr(avcopy, '__setitem__')
+        assert not hasattr(self.adjview, "__setitem__")
+        assert hasattr(avcopy, "__setitem__")
 
 
 class TestFilteredGraphs:
     def setup(self):
-        self.Graphs = [nx.Graph,
-                       nx.DiGraph,
-                       nx.MultiGraph,
-                       nx.MultiDiGraph]
+        self.Graphs = [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
         self.SubGraphs = [nx.graphviews.subgraph_view] * 4
 
     def test_hide_show_nodes(self):
diff --git a/networkx/classes/tests/test_digraph.py b/networkx/classes/tests/test_digraph.py
index ea475b60..76702827 100644
--- a/networkx/classes/tests/test_digraph.py
+++ b/networkx/classes/tests/test_digraph.py
@@ -52,11 +52,11 @@ class BaseDiGraphTester(BaseGraphTester):
         assert sorted(G.out_edges(2)) == []
 
     def test_out_edges_data(self):
-        G = nx.DiGraph([(0, 1, {'data': 0}), (1, 0, {})])
-        assert sorted(G.out_edges(data=True)) == [(0, 1, {'data': 0}), (1, 0, {})]
-        assert sorted(G.out_edges(0, data=True)) == [(0, 1, {'data': 0})]
-        assert sorted(G.out_edges(data='data')) == [(0, 1, 0), (1, 0, None)]
-        assert sorted(G.out_edges(0, data='data')) == [(0, 1, 0)]
+        G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})])
+        assert sorted(G.out_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})]
+        assert sorted(G.out_edges(0, data=True)) == [(0, 1, {"data": 0})]
+        assert sorted(G.out_edges(data="data")) == [(0, 1, 0), (1, 0, None)]
+        assert sorted(G.out_edges(0, data="data")) == [(0, 1, 0)]
 
     def test_in_edges_dir(self):
         G = self.P3
@@ -65,19 +65,18 @@ class BaseDiGraphTester(BaseGraphTester):
         assert sorted(G.in_edges(2)) == [(1, 2)]
 
     def test_in_edges_data(self):
-        G = nx.DiGraph([(0, 1, {'data': 0}), (1, 0, {})])
-        assert sorted(G.in_edges(data=True)) == [(0, 1, {'data': 0}), (1, 0, {})]
-        assert sorted(G.in_edges(1, data=True)) == [(0, 1, {'data': 0})]
-        assert sorted(G.in_edges(data='data')) == [(0, 1, 0), (1, 0, None)]
-        assert sorted(G.in_edges(1, data='data')) == [(0, 1, 0)]
+        G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})])
+        assert sorted(G.in_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})]
+        assert sorted(G.in_edges(1, data=True)) == [(0, 1, {"data": 0})]
+        assert sorted(G.in_edges(data="data")) == [(0, 1, 0), (1, 0, None)]
+        assert sorted(G.in_edges(1, data="data")) == [(0, 1, 0)]
 
     def test_degree(self):
         G = self.K3
         assert sorted(G.degree()) == [(0, 4), (1, 4), (2, 4)]
         assert dict(G.degree()) == {0: 4, 1: 4, 2: 4}
         assert G.degree(0) == 4
-        assert list(G.degree(iter([0]))) == [
-                     (0, 4)]  # run through iterator
+        assert list(G.degree(iter([0]))) == [(0, 4)]  # run through iterator
 
     def test_in_degree(self):
         G = self.K3
@@ -124,6 +123,7 @@ class BaseDiGraphTester(BaseGraphTester):
     def test_reverse_hashable(self):
         class Foo:
             pass
+
         x = Foo()
         y = Foo()
         G = nx.DiGraph()
@@ -135,8 +135,14 @@ class BaseDiGraphTester(BaseGraphTester):
 class BaseAttrDiGraphTester(BaseDiGraphTester, BaseAttrGraphTester):
     def test_edges_data(self):
         G = self.K3
-        all_edges = [(0, 1, {}), (0, 2, {}), (1, 0, {}),
-                     (1, 2, {}), (2, 0, {}), (2, 1, {})]
+        all_edges = [
+            (0, 1, {}),
+            (0, 2, {}),
+            (1, 0, {}),
+            (1, 2, {}),
+            (2, 0, {}),
+            (2, 1, {}),
+        ]
         assert sorted(G.edges(data=True)) == all_edges
         assert sorted(G.edges(0, data=True)) == all_edges[:2]
         assert sorted(G.edges([0, 1], data=True)) == all_edges[:4]
@@ -146,24 +152,24 @@ class BaseAttrDiGraphTester(BaseDiGraphTester, BaseAttrGraphTester):
     def test_in_degree_weighted(self):
         G = self.K3.copy()
         G.add_edge(0, 1, weight=0.3, other=1.2)
-        assert sorted(G.in_degree(weight='weight')) == [(0, 2), (1, 1.3), (2, 2)]
-        assert dict(G.in_degree(weight='weight')) == {0: 2, 1: 1.3, 2: 2}
-        assert G.in_degree(1, weight='weight') == 1.3
-        assert sorted(G.in_degree(weight='other')) == [(0, 2), (1, 2.2), (2, 2)]
-        assert dict(G.in_degree(weight='other')) == {0: 2, 1: 2.2, 2: 2}
-        assert G.in_degree(1, weight='other') == 2.2
-        assert list(G.in_degree(iter([1]), weight='other')) == [(1, 2.2)]
+        assert sorted(G.in_degree(weight="weight")) == [(0, 2), (1, 1.3), (2, 2)]
+        assert dict(G.in_degree(weight="weight")) == {0: 2, 1: 1.3, 2: 2}
+        assert G.in_degree(1, weight="weight") == 1.3
+        assert sorted(G.in_degree(weight="other")) == [(0, 2), (1, 2.2), (2, 2)]
+        assert dict(G.in_degree(weight="other")) == {0: 2, 1: 2.2, 2: 2}
+        assert G.in_degree(1, weight="other") == 2.2
+        assert list(G.in_degree(iter([1]), weight="other")) == [(1, 2.2)]
 
     def test_out_degree_weighted(self):
         G = self.K3.copy()
         G.add_edge(0, 1, weight=0.3, other=1.2)
-        assert sorted(G.out_degree(weight='weight')) == [(0, 1.3), (1, 2), (2, 2)]
-        assert dict(G.out_degree(weight='weight')) == {0: 1.3, 1: 2, 2: 2}
-        assert G.out_degree(0, weight='weight') == 1.3
-        assert sorted(G.out_degree(weight='other')) == [(0, 2.2), (1, 2), (2, 2)]
-        assert dict(G.out_degree(weight='other')) == {0: 2.2, 1: 2, 2: 2}
-        assert G.out_degree(0, weight='other') == 2.2
-        assert list(G.out_degree(iter([0]), weight='other')) == [(0, 2.2)]
+        assert sorted(G.out_degree(weight="weight")) == [(0, 1.3), (1, 2), (2, 2)]
+        assert dict(G.out_degree(weight="weight")) == {0: 1.3, 1: 2, 2: 2}
+        assert G.out_degree(0, weight="weight") == 1.3
+        assert sorted(G.out_degree(weight="other")) == [(0, 2.2), (1, 2), (2, 2)]
+        assert dict(G.out_degree(weight="other")) == {0: 2.2, 1: 2, 2: 2}
+        assert G.out_degree(0, weight="other") == 2.2
+        assert list(G.out_degree(iter([0]), weight="other")) == [(0, 2.2)]
 
 
 class TestDiGraph(BaseAttrDiGraphTester, _TestGraph):
@@ -215,10 +221,10 @@ class TestDiGraph(BaseAttrDiGraphTester, _TestGraph):
 
     def test_add_edges_from(self):
         G = self.Graph()
-        G.add_edges_from([(0, 1), (0, 2, {'data': 3})], data=2)
-        assert G.adj == {0: {1: {'data': 2}, 2: {'data': 3}}, 1: {}, 2: {}}
-        assert G.succ == {0: {1: {'data': 2}, 2: {'data': 3}}, 1: {}, 2: {}}
-        assert G.pred == {0: {}, 1: {0: {'data': 2}}, 2: {0: {'data': 3}}}
+        G.add_edges_from([(0, 1), (0, 2, {"data": 3})], data=2)
+        assert G.adj == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}}
+        assert G.succ == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}}
+        assert G.pred == {0: {}, 1: {0: {"data": 2}}, 2: {0: {"data": 3}}}
 
         with pytest.raises(nx.NetworkXError):
             G.add_edges_from([(0,)])  # too few in tuple
@@ -244,7 +250,7 @@ class TestDiGraph(BaseAttrDiGraphTester, _TestGraph):
 
     def test_clear(self):
         G = self.K3
-        G.graph['name'] = 'K3'
+        G.graph["name"] = "K3"
         G.clear()
         assert list(G.nodes) == []
         assert G.succ == {}
@@ -253,7 +259,7 @@ class TestDiGraph(BaseAttrDiGraphTester, _TestGraph):
 
     def test_clear_edges(self):
         G = self.K3
-        G.graph['name'] = 'K3'
+        G.graph["name"] = "K3"
         nodes = list(G.nodes)
         G.clear_edges()
         assert list(G.nodes) == nodes
@@ -261,7 +267,7 @@ class TestDiGraph(BaseAttrDiGraphTester, _TestGraph):
         assert G.succ == expected
         assert G.pred == expected
         assert list(G.edges) == []
-        assert G.graph['name'] == 'K3'
+        assert G.graph["name"] == "K3"
 
 
 class TestEdgeSubgraph(_TestGraphEdgeSubgraph):
@@ -272,10 +278,10 @@ class TestEdgeSubgraph(_TestGraphEdgeSubgraph):
         G = nx.DiGraph(nx.path_graph(5))
         # Add some node, edge, and graph attributes.
         for i in range(5):
-            G.nodes[i]['name'] = f'node{i}'
-        G.edges[0, 1]['name'] = 'edge01'
-        G.edges[3, 4]['name'] = 'edge34'
-        G.graph['name'] = 'graph'
+            G.nodes[i]["name"] = f"node{i}"
+        G.edges[0, 1]["name"] = "edge01"
+        G.edges[3, 4]["name"] = "edge34"
+        G.graph["name"] = "graph"
         # Get the subgraph induced by the first and last edges.
         self.G = G
         self.H = G.edge_subgraph([(0, 1), (3, 4)])
diff --git a/networkx/classes/tests/test_digraph_historical.py b/networkx/classes/tests/test_digraph_historical.py
index 459da10f..7047bbf3 100644
--- a/networkx/classes/tests/test_digraph_historical.py
+++ b/networkx/classes/tests/test_digraph_historical.py
@@ -7,7 +7,6 @@ from .historical_tests import HistoricalTests
 
 
 class TestDiGraphHistorical(HistoricalTests):
-
     @classmethod
     def setup_class(cls):
         HistoricalTests.setup_class()
@@ -15,23 +14,34 @@ class TestDiGraphHistorical(HistoricalTests):
 
     def test_in_degree(self):
         G = self.G()
-        G.add_nodes_from('GJK')
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('B', 'C'), ('C', 'D')])
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
 
         assert sorted(d for n, d in G.in_degree()) == [0, 0, 0, 0, 1, 2, 2]
-        assert (dict(G.in_degree()) ==
-                {'A': 0, 'C': 2, 'B': 1, 'D': 2, 'G': 0, 'K': 0, 'J': 0})
+        assert dict(G.in_degree()) == {
+            "A": 0,
+            "C": 2,
+            "B": 1,
+            "D": 2,
+            "G": 0,
+            "K": 0,
+            "J": 0,
+        }
 
     def test_out_degree(self):
         G = self.G()
-        G.add_nodes_from('GJK')
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('B', 'C'), ('C', 'D')])
-        assert (sorted([v for k, v in G.in_degree()]) ==
-                [0, 0, 0, 0, 1, 2, 2])
-        assert (dict(G.out_degree()) ==
-                {'A': 2, 'C': 1, 'B': 2, 'D': 0, 'G': 0, 'K': 0, 'J': 0})
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+        assert sorted([v for k, v in G.in_degree()]) == [0, 0, 0, 0, 1, 2, 2]
+        assert dict(G.out_degree()) == {
+            "A": 2,
+            "C": 1,
+            "B": 2,
+            "D": 0,
+            "G": 0,
+            "K": 0,
+            "J": 0,
+        }
 
     def test_degree_digraph(self):
         H = nx.DiGraph()
@@ -42,44 +52,41 @@ class TestDiGraphHistorical(HistoricalTests):
 
     def test_neighbors(self):
         G = self.G()
-        G.add_nodes_from('GJK')
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('B', 'C'), ('C', 'D')])
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
 
-        assert sorted(G.neighbors('C')) == ['D']
-        assert sorted(G['C']) == ['D']
-        assert sorted(G.neighbors('A')) == ['B', 'C']
-        pytest.raises(nx.NetworkXError, G.neighbors, 'j')
-        pytest.raises(nx.NetworkXError, G.neighbors, 'j')
+        assert sorted(G.neighbors("C")) == ["D"]
+        assert sorted(G["C"]) == ["D"]
+        assert sorted(G.neighbors("A")) == ["B", "C"]
+        pytest.raises(nx.NetworkXError, G.neighbors, "j")
+        pytest.raises(nx.NetworkXError, G.neighbors, "j")
 
     def test_successors(self):
         G = self.G()
-        G.add_nodes_from('GJK')
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('B', 'C'), ('C', 'D')])
-        assert sorted(G.successors('A')) == ['B', 'C']
-        assert sorted(G.successors('A')) == ['B', 'C']
-        assert sorted(G.successors('G')) == []
-        assert sorted(G.successors('D')) == []
-        assert sorted(G.successors('G')) == []
-        pytest.raises(nx.NetworkXError, G.successors, 'j')
-        pytest.raises(nx.NetworkXError, G.successors, 'j')
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+        assert sorted(G.successors("A")) == ["B", "C"]
+        assert sorted(G.successors("A")) == ["B", "C"]
+        assert sorted(G.successors("G")) == []
+        assert sorted(G.successors("D")) == []
+        assert sorted(G.successors("G")) == []
+        pytest.raises(nx.NetworkXError, G.successors, "j")
+        pytest.raises(nx.NetworkXError, G.successors, "j")
 
     def test_predecessors(self):
         G = self.G()
-        G.add_nodes_from('GJK')
-        G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'D'),
-                          ('B', 'C'), ('C', 'D')])
-        assert sorted(G.predecessors('C')) == ['A', 'B']
-        assert sorted(G.predecessors('C')) == ['A', 'B']
-        assert sorted(G.predecessors('G')) == []
-        assert sorted(G.predecessors('A')) == []
-        assert sorted(G.predecessors('G')) == []
-        assert sorted(G.predecessors('A')) == []
-        assert sorted(G.successors('D')) == []
-
-        pytest.raises(nx.NetworkXError, G.predecessors, 'j')
-        pytest.raises(nx.NetworkXError, G.predecessors, 'j')
+        G.add_nodes_from("GJK")
+        G.add_edges_from([("A", "B"), ("A", "C"), ("B", "D"), ("B", "C"), ("C", "D")])
+        assert sorted(G.predecessors("C")) == ["A", "B"]
+        assert sorted(G.predecessors("C")) == ["A", "B"]
+        assert sorted(G.predecessors("G")) == []
+        assert sorted(G.predecessors("A")) == []
+        assert sorted(G.predecessors("G")) == []
+        assert sorted(G.predecessors("A")) == []
+        assert sorted(G.successors("D")) == []
+
+        pytest.raises(nx.NetworkXError, G.predecessors, "j")
+        pytest.raises(nx.NetworkXError, G.predecessors, "j")
 
     def test_reverse(self):
         G = nx.complete_graph(10)
diff --git a/networkx/classes/tests/test_filters.py b/networkx/classes/tests/test_filters.py
index 104d9779..b8fe40b6 100644
--- a/networkx/classes/tests/test_filters.py
+++ b/networkx/classes/tests/test_filters.py
@@ -16,7 +16,7 @@ class TestFilterFactory:
         assert not f(3)
         assert f(4)
         assert f(0)
-        assert f('a')
+        assert f("a")
         pytest.raises(TypeError, f, 1, 2)
         pytest.raises(TypeError, f)
 
@@ -27,7 +27,7 @@ class TestFilterFactory:
         assert f(3)
         assert not f(4)
         assert not f(0)
-        assert not f('a')
+        assert not f("a")
         pytest.raises(TypeError, f, 1, 2)
         pytest.raises(TypeError, f)
 
@@ -39,7 +39,7 @@ class TestFilterFactory:
         assert not f(4, 3)
         assert f(2, 3)
         assert f(0, -1)
-        assert f('a', 'b')
+        assert f("a", "b")
         pytest.raises(TypeError, f, 1, 2, 3)
         pytest.raises(TypeError, f, 1)
         pytest.raises(TypeError, f)
@@ -54,7 +54,7 @@ class TestFilterFactory:
         assert f(4, 3)
         assert not f(2, 3)
         assert not f(0, -1)
-        assert not f('a', 'b')
+        assert not f("a", "b")
         pytest.raises(TypeError, f, 1, 2, 3)
         pytest.raises(TypeError, f, 1)
         pytest.raises(TypeError, f)
@@ -69,7 +69,7 @@ class TestFilterFactory:
         assert f(4, 3)
         assert f(2, 3)
         assert f(0, -1)
-        assert f('a', 'b')
+        assert f("a", "b")
         pytest.raises(TypeError, f, 1, 2, 3)
         pytest.raises(TypeError, f, 1)
         pytest.raises(TypeError, f)
@@ -84,7 +84,7 @@ class TestFilterFactory:
         assert not f(4, 3)
         assert not f(2, 3)
         assert not f(0, -1)
-        assert not f('a', 'b')
+        assert not f("a", "b")
         pytest.raises(TypeError, f, 1, 2, 3)
         pytest.raises(TypeError, f, 1)
         pytest.raises(TypeError, f)
@@ -103,7 +103,7 @@ class TestFilterFactory:
         assert f(4, 3, 0)
         assert f(2, 3, 0)
         assert f(0, -1, 0)
-        assert f('a', 'b', 0)
+        assert f("a", "b", 0)
         pytest.raises(TypeError, f, 1, 2, 3, 4)
         pytest.raises(TypeError, f, 1, 2)
         pytest.raises(TypeError, f, 1)
@@ -124,7 +124,7 @@ class TestFilterFactory:
         assert not f(4, 3, 0)
         assert not f(2, 3, 0)
         assert not f(0, -1, 0)
-        assert not f('a', 'b', 0)
+        assert not f("a", "b", 0)
         pytest.raises(TypeError, f, 1, 2, 3, 4)
         pytest.raises(TypeError, f, 1, 2)
         pytest.raises(TypeError, f, 1)
@@ -145,7 +145,7 @@ class TestFilterFactory:
         assert f(4, 3, 0)
         assert f(2, 3, 0)
         assert f(0, -1, 0)
-        assert f('a', 'b', 0)
+        assert f("a", "b", 0)
         pytest.raises(TypeError, f, 1, 2, 3, 4)
         pytest.raises(TypeError, f, 1, 2)
         pytest.raises(TypeError, f, 1)
@@ -166,7 +166,7 @@ class TestFilterFactory:
         assert not f(4, 3, 0)
         assert not f(2, 3, 0)
         assert not f(0, -1, 0)
-        assert not f('a', 'b', 0)
+        assert not f("a", "b", 0)
         pytest.raises(TypeError, f, 1, 2, 3, 4)
         pytest.raises(TypeError, f, 1, 2)
         pytest.raises(TypeError, f, 1)
diff --git a/networkx/classes/tests/test_function.py b/networkx/classes/tests/test_function.py
index 5310ef11..ed87e4d7 100644
--- a/networkx/classes/tests/test_function.py
+++ b/networkx/classes/tests/test_function.py
@@ -6,7 +6,7 @@ from networkx.testing.utils import assert_edges_equal, assert_nodes_equal
 
 class TestFunction:
     def setup_method(self):
-        self.G = nx.Graph({0: [1, 2, 3], 1: [1, 2, 0], 4: []}, name='Test')
+        self.G = nx.Graph({0: [1, 2, 3], 1: [1, 2, 0], 4: []}, name="Test")
         self.Gdegree = {0: 3, 1: 2, 2: 2, 3: 1, 4: 0}
         self.Gnodes = list(range(5))
         self.Gedges = [(0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2)]
@@ -23,22 +23,28 @@ class TestFunction:
     def test_edges(self):
         assert_edges_equal(self.G.edges(), list(nx.edges(self.G)))
         assert sorted(self.DG.edges()) == sorted(nx.edges(self.DG))
-        assert_edges_equal(self.G.edges(nbunch=[0, 1, 3]),
-                           list(nx.edges(self.G, nbunch=[0, 1, 3])))
-        assert (sorted(self.DG.edges(nbunch=[0, 1, 3])) ==
-                sorted(nx.edges(self.DG, nbunch=[0, 1, 3])))
+        assert_edges_equal(
+            self.G.edges(nbunch=[0, 1, 3]), list(nx.edges(self.G, nbunch=[0, 1, 3]))
+        )
+        assert sorted(self.DG.edges(nbunch=[0, 1, 3])) == sorted(
+            nx.edges(self.DG, nbunch=[0, 1, 3])
+        )
 
     def test_degree(self):
         assert_edges_equal(self.G.degree(), list(nx.degree(self.G)))
         assert sorted(self.DG.degree()) == sorted(nx.degree(self.DG))
-        assert_edges_equal(self.G.degree(nbunch=[0, 1]),
-                           list(nx.degree(self.G, nbunch=[0, 1])))
-        assert (sorted(self.DG.degree(nbunch=[0, 1])) ==
-                sorted(nx.degree(self.DG, nbunch=[0, 1])))
-        assert_edges_equal(self.G.degree(weight='weight'),
-                           list(nx.degree(self.G, weight='weight')))
-        assert (sorted(self.DG.degree(weight='weight')) ==
-                sorted(nx.degree(self.DG, weight='weight')))
+        assert_edges_equal(
+            self.G.degree(nbunch=[0, 1]), list(nx.degree(self.G, nbunch=[0, 1]))
+        )
+        assert sorted(self.DG.degree(nbunch=[0, 1])) == sorted(
+            nx.degree(self.DG, nbunch=[0, 1])
+        )
+        assert_edges_equal(
+            self.G.degree(weight="weight"), list(nx.degree(self.G, weight="weight"))
+        )
+        assert sorted(self.DG.degree(weight="weight")) == sorted(
+            nx.degree(self.DG, weight="weight")
+        )
 
     def test_neighbors(self):
         assert list(self.G.neighbors(1)) == list(nx.neighbors(self.G, 1))
@@ -64,10 +70,14 @@ class TestFunction:
 
         G = self.G.copy()
         nx.add_star(G, nlist, weight=2.0)
-        assert_edges_equal(G.edges(nlist, data=True),
-                           [(12, 13, {'weight': 2.}),
-                            (12, 14, {'weight': 2.}),
-                            (12, 15, {'weight': 2.})])
+        assert_edges_equal(
+            G.edges(nlist, data=True),
+            [
+                (12, 13, {"weight": 2.0}),
+                (12, 14, {"weight": 2.0}),
+                (12, 15, {"weight": 2.0}),
+            ],
+        )
 
         G = self.G.copy()
         nlist = [12]
@@ -87,10 +97,14 @@ class TestFunction:
         assert_edges_equal(G.edges(nlist), [(12, 13), (13, 14), (14, 15)])
         G = self.G.copy()
         nx.add_path(G, nlist, weight=2.0)
-        assert_edges_equal(G.edges(nlist, data=True),
-                           [(12, 13, {'weight': 2.}),
-                            (13, 14, {'weight': 2.}),
-                            (14, 15, {'weight': 2.})])
+        assert_edges_equal(
+            G.edges(nlist, data=True),
+            [
+                (12, 13, {"weight": 2.0}),
+                (13, 14, {"weight": 2.0}),
+                (14, 15, {"weight": 2.0}),
+            ],
+        )
 
         G = self.G.copy()
         nlist = [None]
@@ -131,19 +145,27 @@ class TestFunction:
     def test_add_cycle(self):
         G = self.G.copy()
         nlist = [12, 13, 14, 15]
-        oklists = [[(12, 13), (12, 15), (13, 14), (14, 15)],
-                   [(12, 13), (13, 14), (14, 15), (15, 12)]]
+        oklists = [
+            [(12, 13), (12, 15), (13, 14), (14, 15)],
+            [(12, 13), (13, 14), (14, 15), (15, 12)],
+        ]
         nx.add_cycle(G, nlist)
         assert sorted(G.edges(nlist)) in oklists
         G = self.G.copy()
-        oklists = [[(12, 13, {'weight': 1.}),
-                    (12, 15, {'weight': 1.}),
-                    (13, 14, {'weight': 1.}),
-                    (14, 15, {'weight': 1.})],
-                   [(12, 13, {'weight': 1.}),
-                    (13, 14, {'weight': 1.}),
-                    (14, 15, {'weight': 1.}),
-                    (15, 12, {'weight': 1.})]]
+        oklists = [
+            [
+                (12, 13, {"weight": 1.0}),
+                (12, 15, {"weight": 1.0}),
+                (13, 14, {"weight": 1.0}),
+                (14, 15, {"weight": 1.0}),
+            ],
+            [
+                (12, 13, {"weight": 1.0}),
+                (13, 14, {"weight": 1.0}),
+                (14, 15, {"weight": 1.0}),
+                (15, 12, {"weight": 1.0}),
+            ],
+        ]
         nx.add_cycle(G, nlist, weight=1.0)
         assert sorted(G.edges(nlist, data=True)) in oklists
 
@@ -159,24 +181,34 @@ class TestFunction:
         assert_edges_equal(G.edges, self.G.edges)
 
     def test_subgraph(self):
-        assert (self.G.subgraph([0, 1, 2, 4]).adj ==
-                nx.subgraph(self.G, [0, 1, 2, 4]).adj)
-        assert (self.DG.subgraph([0, 1, 2, 4]).adj ==
-                nx.subgraph(self.DG, [0, 1, 2, 4]).adj)
-        assert (self.G.subgraph([0, 1, 2, 4]).adj ==
-                nx.induced_subgraph(self.G, [0, 1, 2, 4]).adj)
-        assert (self.DG.subgraph([0, 1, 2, 4]).adj ==
-                nx.induced_subgraph(self.DG, [0, 1, 2, 4]).adj)
+        assert (
+            self.G.subgraph([0, 1, 2, 4]).adj == nx.subgraph(self.G, [0, 1, 2, 4]).adj
+        )
+        assert (
+            self.DG.subgraph([0, 1, 2, 4]).adj == nx.subgraph(self.DG, [0, 1, 2, 4]).adj
+        )
+        assert (
+            self.G.subgraph([0, 1, 2, 4]).adj
+            == nx.induced_subgraph(self.G, [0, 1, 2, 4]).adj
+        )
+        assert (
+            self.DG.subgraph([0, 1, 2, 4]).adj
+            == nx.induced_subgraph(self.DG, [0, 1, 2, 4]).adj
+        )
         # subgraph-subgraph chain is allowed in function interface
         H = nx.induced_subgraph(self.G.subgraph([0, 1, 2, 4]), [0, 1, 4])
         assert H._graph is not self.G
         assert H.adj == self.G.subgraph([0, 1, 4]).adj
 
     def test_edge_subgraph(self):
-        assert (self.G.edge_subgraph([(1, 2), (0, 3)]).adj ==
-                nx.edge_subgraph(self.G, [(1, 2), (0, 3)]).adj)
-        assert (self.DG.edge_subgraph([(1, 2), (0, 3)]).adj ==
-                nx.edge_subgraph(self.DG, [(1, 2), (0, 3)]).adj)
+        assert (
+            self.G.edge_subgraph([(1, 2), (0, 3)]).adj
+            == nx.edge_subgraph(self.G, [(1, 2), (0, 3)]).adj
+        )
+        assert (
+            self.DG.edge_subgraph([(1, 2), (0, 3)]).adj
+            == nx.edge_subgraph(self.DG, [(1, 2), (0, 3)]).adj
+        )
 
     def test_restricted_view(self):
         H = nx.restricted_view(self.G, [0, 2, 5], [(1, 2), (3, 4)])
@@ -235,41 +267,47 @@ class TestFunction:
         G = nx.path_graph(5)
         G.name = "path_graph(5)"
         info = nx.info(G)
-        expected_graph_info = '\n'.join(['Name: path_graph(5)',
-                                         'Type: Graph',
-                                         'Number of nodes: 5',
-                                         'Number of edges: 4',
-                                         'Average degree:   1.6000'])
+        expected_graph_info = "\n".join(
+            [
+                "Name: path_graph(5)",
+                "Type: Graph",
+                "Number of nodes: 5",
+                "Number of edges: 4",
+                "Average degree:   1.6000",
+            ]
+        )
         assert info == expected_graph_info
 
         info = nx.info(G, n=1)
         assert type(info) == str
-        expected_node_info = '\n'.join(
-            ['Node 1 has the following properties:',
-             'Degree: 2',
-             'Neighbors: 0 2'])
+        expected_node_info = "\n".join(
+            ["Node 1 has the following properties:", "Degree: 2", "Neighbors: 0 2"]
+        )
         assert info == expected_node_info
 
         # must raise an error for a non-existent node
         pytest.raises(nx.NetworkXError, nx.info, G, 1248)
 
     def test_info_digraph(self):
-        G = nx.DiGraph(name='path_graph(5)')
+        G = nx.DiGraph(name="path_graph(5)")
         nx.add_path(G, [0, 1, 2, 3, 4])
         info = nx.info(G)
-        expected_graph_info = '\n'.join(['Name: path_graph(5)',
-                                         'Type: DiGraph',
-                                         'Number of nodes: 5',
-                                         'Number of edges: 4',
-                                         'Average in degree:   0.8000',
-                                         'Average out degree:   0.8000'])
+        expected_graph_info = "\n".join(
+            [
+                "Name: path_graph(5)",
+                "Type: DiGraph",
+                "Number of nodes: 5",
+                "Number of edges: 4",
+                "Average in degree:   0.8000",
+                "Average out degree:   0.8000",
+            ]
+        )
         assert info == expected_graph_info
 
         info = nx.info(G, n=1)
-        expected_node_info = '\n'.join(
-            ['Node 1 has the following properties:',
-             'Degree: 2',
-             'Neighbors: 2'])
+        expected_node_info = "\n".join(
+            ["Node 1 has the following properties:", "Degree: 2", "Neighbors: 2"]
+        )
         assert info == expected_node_info
 
         pytest.raises(nx.NetworkXError, nx.info, G, n=-1)
@@ -362,15 +400,22 @@ class TestFunction:
         assert nx.is_weighted(G, (3, 4))
 
         G = nx.DiGraph()
-        G.add_weighted_edges_from([('0', '3', 3), ('0', '1', -5),
-                                   ('1', '0', -5), ('0', '2', 2),
-                                   ('1', '2', 4), ('2', '3', 1)])
+        G.add_weighted_edges_from(
+            [
+                ("0", "3", 3),
+                ("0", "1", -5),
+                ("1", "0", -5),
+                ("0", "2", 2),
+                ("1", "2", 4),
+                ("2", "3", 1),
+            ]
+        )
         assert nx.is_weighted(G)
-        assert nx.is_weighted(G, ('1', '0'))
+        assert nx.is_weighted(G, ("1", "0"))
 
         G = G.to_undirected()
         assert nx.is_weighted(G)
-        assert nx.is_weighted(G, ('1', '0'))
+        assert nx.is_weighted(G, ("1", "0"))
 
         pytest.raises(nx.NetworkXError, nx.is_weighted, G, (1, 2))
 
@@ -386,26 +431,33 @@ class TestFunction:
         assert not nx.is_negatively_weighted(G, (1, 2))
 
         G.add_edges_from([(1, 3), (2, 4), (2, 6)])
-        G[1][3]['color'] = 'blue'
+        G[1][3]["color"] = "blue"
         assert not nx.is_negatively_weighted(G)
         assert not nx.is_negatively_weighted(G, (1, 3))
 
-        G[2][4]['weight'] = -2
+        G[2][4]["weight"] = -2
         assert nx.is_negatively_weighted(G, (2, 4))
         assert nx.is_negatively_weighted(G)
 
         G = nx.DiGraph()
-        G.add_weighted_edges_from([('0', '3', 3), ('0', '1', -5),
-                                   ('1', '0', -2), ('0', '2', 2),
-                                   ('1', '2', -3), ('2', '3', 1)])
+        G.add_weighted_edges_from(
+            [
+                ("0", "3", 3),
+                ("0", "1", -5),
+                ("1", "0", -2),
+                ("0", "2", 2),
+                ("1", "2", -3),
+                ("2", "3", 1),
+            ]
+        )
         assert nx.is_negatively_weighted(G)
-        assert not nx.is_negatively_weighted(G, ('0', '3'))
-        assert nx.is_negatively_weighted(G, ('1', '0'))
+        assert not nx.is_negatively_weighted(G, ("0", "3"))
+        assert nx.is_negatively_weighted(G, ("1", "0"))
 
         pytest.raises(nx.NetworkXError, nx.is_negatively_weighted, G, (1, 4))
 
 
-class TestCommonNeighbors():
+class TestCommonNeighbors:
     @classmethod
     def setup_class(cls):
         cls.func = staticmethod(nx.common_neighbors)
@@ -413,6 +465,7 @@ class TestCommonNeighbors():
         def test_func(G, u, v, expected):
             result = sorted(cls.func(G, u, v))
             assert result == expected
+
         cls.test = staticmethod(test_func)
 
     def test_K5(self):
@@ -457,7 +510,7 @@ def test_set_node_attributes():
         # Test single value
         G = nx.path_graph(3, create_using=G)
         vals = 100
-        attr = 'hello'
+        attr = "hello"
         nx.set_node_attributes(G, vals, attr)
         assert G.nodes[0][attr] == vals
         assert G.nodes[1][attr] == vals
@@ -466,7 +519,7 @@ def test_set_node_attributes():
         # Test dictionary
         G = nx.path_graph(3, create_using=G)
         vals = dict(zip(sorted(G.nodes()), range(len(G))))
-        attr = 'hi'
+        attr = "hi"
         nx.set_node_attributes(G, vals, attr)
         assert G.nodes[0][attr] == 0
         assert G.nodes[1][attr] == 1
@@ -474,7 +527,7 @@ def test_set_node_attributes():
 
         # Test dictionary of dictionaries
         G = nx.path_graph(3, create_using=G)
-        d = {'hi': 0, 'hello': 200}
+        d = {"hi": 0, "hello": 200}
         vals = dict.fromkeys(G.nodes(), d)
         vals.pop(0)
         nx.set_node_attributes(G, vals)
@@ -488,7 +541,7 @@ def test_set_edge_attributes():
     for G in graphs:
         # Test single value
         G = nx.path_graph(3, create_using=G)
-        attr = 'hello'
+        attr = "hello"
         vals = 3
         nx.set_edge_attributes(G, vals, attr)
         assert G[0][1][attr] == vals
@@ -496,7 +549,7 @@ def test_set_edge_attributes():
 
         # Test multiple values
         G = nx.path_graph(3, create_using=G)
-        attr = 'hi'
+        attr = "hi"
         edges = [(0, 1), (1, 2)]
         vals = dict(zip(edges, range(len(edges))))
         nx.set_edge_attributes(G, vals, attr)
@@ -505,12 +558,12 @@ def test_set_edge_attributes():
 
         # Test dictionary of dictionaries
         G = nx.path_graph(3, create_using=G)
-        d = {'hi': 0, 'hello': 200}
+        d = {"hi": 0, "hello": 200}
         edges = [(0, 1)]
         vals = dict.fromkeys(edges, d)
         nx.set_edge_attributes(G, vals)
-        assert G[0][1]['hi'] == 0
-        assert G[0][1]['hello'] == 200
+        assert G[0][1]["hi"] == 0
+        assert G[0][1]["hello"] == 200
         assert G[1][2] == {}
 
 
@@ -519,7 +572,7 @@ def test_set_edge_attributes_multi():
     for G in graphs:
         # Test single value
         G = nx.path_graph(3, create_using=G)
-        attr = 'hello'
+        attr = "hello"
         vals = 3
         nx.set_edge_attributes(G, vals, attr)
         assert G[0][1][0][attr] == vals
@@ -527,7 +580,7 @@ def test_set_edge_attributes_multi():
 
         # Test multiple values
         G = nx.path_graph(3, create_using=G)
-        attr = 'hi'
+        attr = "hi"
         edges = [(0, 1, 0), (1, 2, 0)]
         vals = dict(zip(edges, range(len(edges))))
         nx.set_edge_attributes(G, vals, attr)
@@ -536,12 +589,12 @@ def test_set_edge_attributes_multi():
 
         # Test dictionary of dictionaries
         G = nx.path_graph(3, create_using=G)
-        d = {'hi': 0, 'hello': 200}
+        d = {"hi": 0, "hello": 200}
         edges = [(0, 1, 0)]
         vals = dict.fromkeys(edges, d)
         nx.set_edge_attributes(G, vals)
-        assert G[0][1][0]['hi'] == 0
-        assert G[0][1][0]['hello'] == 200
+        assert G[0][1][0]["hi"] == 0
+        assert G[0][1][0]["hello"] == 200
         assert G[1][2][0] == {}
 
 
@@ -549,7 +602,7 @@ def test_get_node_attributes():
     graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
     for G in graphs:
         G = nx.path_graph(3, create_using=G)
-        attr = 'hello'
+        attr = "hello"
         vals = 100
         nx.set_node_attributes(G, vals, attr)
         attrs = nx.get_node_attributes(G, attr)
@@ -562,7 +615,7 @@ def test_get_edge_attributes():
     graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
     for G in graphs:
         G = nx.path_graph(3, create_using=G)
-        attr = 'hello'
+        attr = "hello"
         vals = 100
         nx.set_edge_attributes(G, vals, attr)
         attrs = nx.get_edge_attributes(G, attr)
@@ -605,7 +658,9 @@ def test_selfloops():
         assert nx.number_of_selfloops(G) == 1
         # test selfloop attr
         G.add_edge(1, 1, weight=2)
-        assert_edges_equal(nx.selfloop_edges(G, data=True),
-                           [(0, 0, {}), (1, 1, {'weight': 2})])
-        assert_edges_equal(nx.selfloop_edges(G, data='weight'),
-                           [(0, 0, None), (1, 1, 2)])
+        assert_edges_equal(
+            nx.selfloop_edges(G, data=True), [(0, 0, {}), (1, 1, {"weight": 2})]
+        )
+        assert_edges_equal(
+            nx.selfloop_edges(G, data="weight"), [(0, 0, None), (1, 1, 2)]
+        )
diff --git a/networkx/classes/tests/test_graph.py b/networkx/classes/tests/test_graph.py
index bf5c87f9..03902b09 100644
--- a/networkx/classes/tests/test_graph.py
+++ b/networkx/classes/tests/test_graph.py
@@ -5,7 +5,7 @@ import networkx as nx
 from networkx.testing.utils import (
     assert_graphs_equal,
     assert_edges_equal,
-    assert_nodes_equal
+    assert_nodes_equal,
 )
 
 import pytest
@@ -16,11 +16,11 @@ class BaseGraphTester:
 
     def test_contains(self):
         G = self.K3
-        assert(1 in G)
-        assert(4 not in G)
-        assert('b' not in G)
-        assert([] not in G)   # no exception for nonhashable
-        assert({1: 1} not in G)  # no exception for nonhashable
+        assert 1 in G
+        assert 4 not in G
+        assert "b" not in G
+        assert [] not in G  # no exception for nonhashable
+        assert {1: 1} not in G  # no exception for nonhashable
 
     def test_order(self):
         G = self.K3
@@ -35,10 +35,10 @@ class BaseGraphTester:
 
     def test_has_node(self):
         G = self.K3
-        assert(G.has_node(1))
-        assert(not G.has_node(4))
-        assert(not G.has_node([]))   # no exception for nonhashable
-        assert(not G.has_node({1: 1}))  # no exception for nonhashable
+        assert G.has_node(1)
+        assert not G.has_node(4)
+        assert not G.has_node([])  # no exception for nonhashable
+        assert not G.has_node({1: 1})  # no exception for nonhashable
 
     def test_has_edge(self):
         G = self.K3
@@ -124,7 +124,7 @@ class BaseGraphTester:
 
         # For more information, see pull request #1813.
         G = self.Graph()
-        nbunch = [('x', set())]
+        nbunch = [("x", set())]
         with pytest.raises(nx.NetworkXError):
             list(G.nbunch_iter(nbunch))
 
@@ -135,7 +135,7 @@ class BaseGraphTester:
         assert dict(G.degree()) == {1: 2}
         assert G.degree(1) == 2
         assert sorted(G.degree([1])) == [(1, 2)]
-        assert G.degree(1, weight='weight') == 2
+        assert G.degree(1, weight="weight") == 2
 
     def test_selfloops(self):
         G = self.K3.copy()
@@ -160,29 +160,28 @@ class BaseAttrGraphTester(BaseGraphTester):
         G = self.Graph()
         G.add_edge(1, 2, weight=2, other=3)
         G.add_edge(2, 3, weight=3, other=4)
-        assert (sorted(d for n, d in G.degree(weight='weight')) ==
-                [2, 3, 5])
-        assert dict(G.degree(weight='weight')) == {1: 2, 2: 5, 3: 3}
-        assert G.degree(1, weight='weight') == 2
-        assert_nodes_equal((G.degree([1], weight='weight')), [(1, 2)])
+        assert sorted(d for n, d in G.degree(weight="weight")) == [2, 3, 5]
+        assert dict(G.degree(weight="weight")) == {1: 2, 2: 5, 3: 3}
+        assert G.degree(1, weight="weight") == 2
+        assert_nodes_equal((G.degree([1], weight="weight")), [(1, 2)])
 
-        assert_nodes_equal((d for n, d in G.degree(weight='other')), [3, 7, 4])
-        assert dict(G.degree(weight='other')) == {1: 3, 2: 7, 3: 4}
-        assert G.degree(1, weight='other') == 3
-        assert_edges_equal((G.degree([1], weight='other')), [(1, 3)])
+        assert_nodes_equal((d for n, d in G.degree(weight="other")), [3, 7, 4])
+        assert dict(G.degree(weight="other")) == {1: 3, 2: 7, 3: 4}
+        assert G.degree(1, weight="other") == 3
+        assert_edges_equal((G.degree([1], weight="other")), [(1, 3)])
 
     def add_attributes(self, G):
-        G.graph['foo'] = []
-        G.nodes[0]['foo'] = []
+        G.graph["foo"] = []
+        G.nodes[0]["foo"] = []
         G.remove_edge(1, 2)
         ll = []
         G.add_edge(1, 2, foo=ll)
         G.add_edge(2, 1, foo=ll)
 
     def test_name(self):
-        G = self.Graph(name='')
+        G = self.Graph(name="")
         assert G.name == ""
-        G = self.Graph(name='test')
+        G = self.Graph(name="test")
         assert G.__str__() == "test"
         assert G.name == "test"
 
@@ -244,19 +243,19 @@ class BaseAttrGraphTester(BaseGraphTester):
         self.deepcopy_edge_attr(H, G)
 
     def deepcopy_graph_attr(self, H, G):
-        assert G.graph['foo'] == H.graph['foo']
-        G.graph['foo'].append(1)
-        assert G.graph['foo'] != H.graph['foo']
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] != H.graph["foo"]
 
     def deepcopy_node_attr(self, H, G):
-        assert G.nodes[0]['foo'] == H.nodes[0]['foo']
-        G.nodes[0]['foo'].append(1)
-        assert G.nodes[0]['foo'] != H.nodes[0]['foo']
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] != H.nodes[0]["foo"]
 
     def deepcopy_edge_attr(self, H, G):
-        assert G[1][2]['foo'] == H[1][2]['foo']
-        G[1][2]['foo'].append(1)
-        assert G[1][2]['foo'] != H[1][2]['foo']
+        assert G[1][2]["foo"] == H[1][2]["foo"]
+        G[1][2]["foo"].append(1)
+        assert G[1][2]["foo"] != H[1][2]["foo"]
 
     def is_shallow_copy(self, H, G):
         self.graphs_equal(H, G)
@@ -268,44 +267,44 @@ class BaseAttrGraphTester(BaseGraphTester):
         self.shallow_copy_edge_attr(H, G)
 
     def shallow_copy_graph_attr(self, H, G):
-        assert G.graph['foo'] == H.graph['foo']
-        G.graph['foo'].append(1)
-        assert G.graph['foo'] == H.graph['foo']
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] == H.graph["foo"]
 
     def shallow_copy_node_attr(self, H, G):
-        assert G.nodes[0]['foo'] == H.nodes[0]['foo']
-        G.nodes[0]['foo'].append(1)
-        assert G.nodes[0]['foo'] == H.nodes[0]['foo']
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
 
     def shallow_copy_edge_attr(self, H, G):
-        assert G[1][2]['foo'] == H[1][2]['foo']
-        G[1][2]['foo'].append(1)
-        assert G[1][2]['foo'] == H[1][2]['foo']
+        assert G[1][2]["foo"] == H[1][2]["foo"]
+        G[1][2]["foo"].append(1)
+        assert G[1][2]["foo"] == H[1][2]["foo"]
 
     def same_attrdict(self, H, G):
-        old_foo = H[1][2]['foo']
-        H.adj[1][2]['foo'] = 'baz'
+        old_foo = H[1][2]["foo"]
+        H.adj[1][2]["foo"] = "baz"
         assert G.edges == H.edges
-        H.adj[1][2]['foo'] = old_foo
+        H.adj[1][2]["foo"] = old_foo
         assert G.edges == H.edges
 
-        old_foo = H.nodes[0]['foo']
-        H.nodes[0]['foo'] = 'baz'
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
         assert G.nodes == H.nodes
-        H.nodes[0]['foo'] = old_foo
+        H.nodes[0]["foo"] = old_foo
         assert G.nodes == H.nodes
 
     def different_attrdict(self, H, G):
-        old_foo = H[1][2]['foo']
-        H.adj[1][2]['foo'] = 'baz'
+        old_foo = H[1][2]["foo"]
+        H.adj[1][2]["foo"] = "baz"
         assert G._adj != H._adj
-        H.adj[1][2]['foo'] = old_foo
+        H.adj[1][2]["foo"] = old_foo
         assert G._adj == H._adj
 
-        old_foo = H.nodes[0]['foo']
-        H.nodes[0]['foo'] = 'baz'
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
         assert G._node != H._node
-        H.nodes[0]['foo'] = old_foo
+        H.nodes[0]["foo"] = old_foo
         assert G._node == H._node
 
     def graphs_equal(self, H, G):
@@ -330,86 +329,98 @@ class BaseAttrGraphTester(BaseGraphTester):
 
     def test_graph_attr(self):
         G = self.K3.copy()
-        G.graph['foo'] = 'bar'
-        assert G.graph['foo'] == 'bar'
-        del G.graph['foo']
+        G.graph["foo"] = "bar"
+        assert G.graph["foo"] == "bar"
+        del G.graph["foo"]
         assert G.graph == {}
-        H = self.Graph(foo='bar')
-        assert H.graph['foo'] == 'bar'
+        H = self.Graph(foo="bar")
+        assert H.graph["foo"] == "bar"
 
     def test_node_attr(self):
         G = self.K3.copy()
-        G.add_node(1, foo='bar')
+        G.add_node(1, foo="bar")
         assert_nodes_equal(G.nodes(), [0, 1, 2])
-        assert_nodes_equal(G.nodes(data=True),
-                           [(0, {}), (1, {'foo': 'bar'}), (2, {})])
-        G.nodes[1]['foo'] = 'baz'
-        assert_nodes_equal(G.nodes(data=True),
-                           [(0, {}), (1, {'foo': 'baz'}), (2, {})])
-        assert_nodes_equal(G.nodes(data='foo'),
-                           [(0, None), (1, 'baz'), (2, None)])
-        assert_nodes_equal(G.nodes(data='foo', default='bar'),
-                           [(0, 'bar'), (1, 'baz'), (2, 'bar')])
+        assert_nodes_equal(G.nodes(data=True), [(0, {}), (1, {"foo": "bar"}), (2, {})])
+        G.nodes[1]["foo"] = "baz"
+        assert_nodes_equal(G.nodes(data=True), [(0, {}), (1, {"foo": "baz"}), (2, {})])
+        assert_nodes_equal(G.nodes(data="foo"), [(0, None), (1, "baz"), (2, None)])
+        assert_nodes_equal(
+            G.nodes(data="foo", default="bar"), [(0, "bar"), (1, "baz"), (2, "bar")]
+        )
 
     def test_node_attr2(self):
         G = self.K3.copy()
-        a = {'foo': 'bar'}
+        a = {"foo": "bar"}
         G.add_node(3, **a)
         assert_nodes_equal(G.nodes(), [0, 1, 2, 3])
-        assert_nodes_equal(G.nodes(data=True),
-                           [(0, {}), (1, {}), (2, {}), (3, {'foo': 'bar'})])
+        assert_nodes_equal(
+            G.nodes(data=True), [(0, {}), (1, {}), (2, {}), (3, {"foo": "bar"})]
+        )
 
     def test_edge_lookup(self):
         G = self.Graph()
-        G.add_edge(1, 2, foo='bar')
-        assert_edges_equal(G.edges[1, 2], {'foo': 'bar'})
+        G.add_edge(1, 2, foo="bar")
+        assert_edges_equal(G.edges[1, 2], {"foo": "bar"})
 
     def test_edge_attr(self):
         G = self.Graph()
-        G.add_edge(1, 2, foo='bar')
-        assert_edges_equal(G.edges(data=True), [(1, 2, {'foo': 'bar'})])
-        assert_edges_equal(G.edges(data='foo'), [(1, 2, 'bar')])
+        G.add_edge(1, 2, foo="bar")
+        assert_edges_equal(G.edges(data=True), [(1, 2, {"foo": "bar"})])
+        assert_edges_equal(G.edges(data="foo"), [(1, 2, "bar")])
 
     def test_edge_attr2(self):
         G = self.Graph()
-        G.add_edges_from([(1, 2), (3, 4)], foo='foo')
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'foo': 'foo'}), (3, 4, {'foo': 'foo'})])
-        assert_edges_equal(G.edges(data='foo'),
-                           [(1, 2, 'foo'), (3, 4, 'foo')])
+        G.add_edges_from([(1, 2), (3, 4)], foo="foo")
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"foo": "foo"}), (3, 4, {"foo": "foo"})]
+        )
+        assert_edges_equal(G.edges(data="foo"), [(1, 2, "foo"), (3, 4, "foo")])
 
     def test_edge_attr3(self):
         G = self.Graph()
-        G.add_edges_from([(1, 2, {'weight': 32}),
-                          (3, 4, {'weight': 64})], foo='foo')
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'foo': 'foo', 'weight': 32}),
-                            (3, 4, {'foo': 'foo', 'weight': 64})])
+        G.add_edges_from([(1, 2, {"weight": 32}), (3, 4, {"weight": 64})], foo="foo")
+        assert_edges_equal(
+            G.edges(data=True),
+            [
+                (1, 2, {"foo": "foo", "weight": 32}),
+                (3, 4, {"foo": "foo", "weight": 64}),
+            ],
+        )
 
         G.remove_edges_from([(1, 2), (3, 4)])
-        G.add_edge(1, 2, data=7, spam='bar', bar='foo')
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 7, 'spam': 'bar', 'bar': 'foo'})])
+        G.add_edge(1, 2, data=7, spam="bar", bar="foo")
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
+        )
 
     def test_edge_attr4(self):
         G = self.Graph()
-        G.add_edge(1, 2, data=7, spam='bar', bar='foo')
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 7, 'spam': 'bar', 'bar': 'foo'})])
-        G[1][2]['data'] = 10  # OK to set data like this
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 10, 'spam': 'bar', 'bar': 'foo'})])
-
-        G.adj[1][2]['data'] = 20
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 20, 'spam': 'bar', 'bar': 'foo'})])
-        G.edges[1, 2]['data'] = 21  # another spelling, "edge"
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 21, 'spam': 'bar', 'bar': 'foo'})])
-        G.adj[1][2]['listdata'] = [20, 200]
-        G.adj[1][2]['weight'] = 20
-        dd = {'data': 21, 'spam': 'bar', 'bar': 'foo',
-              'listdata': [20, 200], 'weight': 20}
+        G.add_edge(1, 2, data=7, spam="bar", bar="foo")
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
+        )
+        G[1][2]["data"] = 10  # OK to set data like this
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 10, "spam": "bar", "bar": "foo"})]
+        )
+
+        G.adj[1][2]["data"] = 20
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 20, "spam": "bar", "bar": "foo"})]
+        )
+        G.edges[1, 2]["data"] = 21  # another spelling, "edge"
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 21, "spam": "bar", "bar": "foo"})]
+        )
+        G.adj[1][2]["listdata"] = [20, 200]
+        G.adj[1][2]["weight"] = 20
+        dd = {
+            "data": 21,
+            "spam": "bar",
+            "bar": "foo",
+            "listdata": [20, 200],
+            "weight": 20,
+        }
         assert_edges_equal(G.edges(data=True), [(1, 2, dd)])
 
     def test_to_undirected(self):
@@ -448,10 +459,12 @@ class BaseAttrGraphTester(BaseGraphTester):
         G = self.K3.copy()
         G.add_edge(0, 0)
         G.add_edge(1, 1, weight=2)
-        assert_edges_equal(nx.selfloop_edges(G, data=True),
-                           [(0, 0, {}), (1, 1, {'weight': 2})])
-        assert_edges_equal(nx.selfloop_edges(G, data='weight'),
-                           [(0, 0, None), (1, 1, 2)])
+        assert_edges_equal(
+            nx.selfloop_edges(G, data=True), [(0, 0, {}), (1, 1, {"weight": 2})]
+        )
+        assert_edges_equal(
+            nx.selfloop_edges(G, data="weight"), [(0, 0, None), (1, 1, 2)]
+        )
 
 
 class TestGraph(BaseAttrGraphTester):
@@ -461,9 +474,7 @@ class TestGraph(BaseAttrGraphTester):
         self.Graph = nx.Graph
         # build dict-of-dict-of-dict K3
         ed1, ed2, ed3 = ({}, {}, {})
-        self.k3adj = {0: {1: ed1, 2: ed2},
-                      1: {0: ed1, 2: ed3},
-                      2: {0: ed2, 1: ed3}}
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed1, 2: ed3}, 2: {0: ed2, 1: ed3}}
         self.k3edges = [(0, 1), (0, 2), (1, 2)]
         self.k3nodes = [0, 1, 2]
         self.K3 = self.Graph()
@@ -490,63 +501,66 @@ class TestGraph(BaseAttrGraphTester):
 
     def test_adjacency(self):
         G = self.K3
-        assert (dict(G.adjacency()) ==
-                {0: {1: {}, 2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}})
+        assert dict(G.adjacency()) == {
+            0: {1: {}, 2: {}},
+            1: {0: {}, 2: {}},
+            2: {0: {}, 1: {}},
+        }
 
     def test_getitem(self):
         G = self.K3
         assert G[0] == {1: {}, 2: {}}
         with pytest.raises(KeyError):
-            G.__getitem__('j')
+            G.__getitem__("j")
         with pytest.raises(TypeError):
-            G.__getitem__(['A'])
+            G.__getitem__(["A"])
 
     def test_add_node(self):
         G = self.Graph()
         G.add_node(0)
         assert G.adj == {0: {}}
         # test add attributes
-        G.add_node(1, c='red')
-        G.add_node(2, c='blue')
-        G.add_node(3, c='red')
-        assert G.nodes[1]['c'] == 'red'
-        assert G.nodes[2]['c'] == 'blue'
-        assert G.nodes[3]['c'] == 'red'
+        G.add_node(1, c="red")
+        G.add_node(2, c="blue")
+        G.add_node(3, c="red")
+        assert G.nodes[1]["c"] == "red"
+        assert G.nodes[2]["c"] == "blue"
+        assert G.nodes[3]["c"] == "red"
         # test updating attributes
-        G.add_node(1, c='blue')
-        G.add_node(2, c='red')
-        G.add_node(3, c='blue')
-        assert G.nodes[1]['c'] == 'blue'
-        assert G.nodes[2]['c'] == 'red'
-        assert G.nodes[3]['c'] == 'blue'
+        G.add_node(1, c="blue")
+        G.add_node(2, c="red")
+        G.add_node(3, c="blue")
+        assert G.nodes[1]["c"] == "blue"
+        assert G.nodes[2]["c"] == "red"
+        assert G.nodes[3]["c"] == "blue"
 
     def test_add_nodes_from(self):
         G = self.Graph()
         G.add_nodes_from([0, 1, 2])
         assert G.adj == {0: {}, 1: {}, 2: {}}
         # test add attributes
-        G.add_nodes_from([0, 1, 2], c='red')
-        assert G.nodes[0]['c'] == 'red'
-        assert G.nodes[2]['c'] == 'red'
+        G.add_nodes_from([0, 1, 2], c="red")
+        assert G.nodes[0]["c"] == "red"
+        assert G.nodes[2]["c"] == "red"
         # test that attribute dicts are not the same
-        assert(G.nodes[0] is not G.nodes[1])
+        assert G.nodes[0] is not G.nodes[1]
         # test updating attributes
-        G.add_nodes_from([0, 1, 2], c='blue')
-        assert G.nodes[0]['c'] == 'blue'
-        assert G.nodes[2]['c'] == 'blue'
-        assert(G.nodes[0] is not G.nodes[1])
+        G.add_nodes_from([0, 1, 2], c="blue")
+        assert G.nodes[0]["c"] == "blue"
+        assert G.nodes[2]["c"] == "blue"
+        assert G.nodes[0] is not G.nodes[1]
         # test tuple input
         H = self.Graph()
         H.add_nodes_from(G.nodes(data=True))
-        assert H.nodes[0]['c'] == 'blue'
-        assert H.nodes[2]['c'] == 'blue'
-        assert(H.nodes[0] is not H.nodes[1])
+        assert H.nodes[0]["c"] == "blue"
+        assert H.nodes[2]["c"] == "blue"
+        assert H.nodes[0] is not H.nodes[1]
         # specific overrides general
-        H.add_nodes_from([0, (1, {'c': 'green'}), (3, {'c': 'cyan'})], c='red')
-        assert H.nodes[0]['c'] == 'red'
-        assert H.nodes[1]['c'] == 'green'
-        assert H.nodes[2]['c'] == 'blue'
-        assert H.nodes[3]['c'] == 'cyan'
+        H.add_nodes_from([0, (1, {"c": "green"}), (3, {"c": "cyan"})], c="red")
+        assert H.nodes[0]["c"] == "red"
+        assert H.nodes[1]["c"] == "green"
+        assert H.nodes[2]["c"] == "blue"
+        assert H.nodes[3]["c"] == "cyan"
 
     def test_remove_node(self):
         G = self.K3.copy()
@@ -556,6 +570,7 @@ class TestGraph(BaseAttrGraphTester):
             G.remove_node(-1)
 
         # generator here to implement list,set,string...
+
     def test_remove_nodes_from(self):
         G = self.K3.copy()
         G.remove_nodes_from([0, 1])
@@ -572,16 +587,18 @@ class TestGraph(BaseAttrGraphTester):
 
     def test_add_edges_from(self):
         G = self.Graph()
-        G.add_edges_from([(0, 1), (0, 2, {'weight': 3})])
-        assert G.adj == {0: {1: {}, 2: {'weight': 3}}, 1: {0: {}},
-                         2: {0: {'weight': 3}}}
+        G.add_edges_from([(0, 1), (0, 2, {"weight": 3})])
+        assert G.adj == {
+            0: {1: {}, 2: {"weight": 3}},
+            1: {0: {}},
+            2: {0: {"weight": 3}},
+        }
         G = self.Graph()
-        G.add_edges_from([(0, 1), (0, 2, {'weight': 3}),
-                          (1, 2, {'data': 4})], data=2)
+        G.add_edges_from([(0, 1), (0, 2, {"weight": 3}), (1, 2, {"data": 4})], data=2)
         assert G.adj == {
-            0: {1: {'data': 2}, 2: {'weight': 3, 'data': 2}},
-            1: {0: {'data': 2}, 2: {'data': 4}},
-            2: {0: {'weight': 3, 'data': 2}, 1: {'data': 4}}
+            0: {1: {"data": 2}, 2: {"weight": 3, "data": 2}},
+            1: {0: {"data": 2}, 2: {"data": 4}},
+            2: {0: {"weight": 3, "data": 2}, 1: {"data": 4}},
         }
 
         with pytest.raises(nx.NetworkXError):
@@ -606,7 +623,7 @@ class TestGraph(BaseAttrGraphTester):
 
     def test_clear(self):
         G = self.K3.copy()
-        G.graph['name'] = 'K3'
+        G.graph["name"] = "K3"
         G.clear()
         assert list(G.nodes) == []
         assert G.adj == {}
@@ -614,13 +631,13 @@ class TestGraph(BaseAttrGraphTester):
 
     def test_clear_edges(self):
         G = self.K3.copy()
-        G.graph['name'] = 'K3'
+        G.graph["name"] = "K3"
         nodes = list(G.nodes)
         G.clear_edges()
         assert list(G.nodes) == nodes
         assert G.adj == {0: {}, 1: {}, 2: {}}
         assert list(G.edges) == []
-        assert G.graph['name'] == 'K3'
+        assert G.graph["name"] == "K3"
 
     def test_edges_data(self):
         G = self.K3
@@ -642,31 +659,50 @@ class TestGraph(BaseAttrGraphTester):
     def test_update(self):
         # specify both edgees and nodes
         G = self.K3.copy()
-        G.update(nodes=[3, (4, {'size': 2})],
-                 edges=[(4, 5), (6, 7, {'weight': 2})])
-        nlist = [(0, {}), (1, {}), (2, {}), (3, {}),
-                 (4, {'size': 2}), (5, {}), (6, {}), (7, {})]
+        G.update(nodes=[3, (4, {"size": 2})], edges=[(4, 5), (6, 7, {"weight": 2})])
+        nlist = [
+            (0, {}),
+            (1, {}),
+            (2, {}),
+            (3, {}),
+            (4, {"size": 2}),
+            (5, {}),
+            (6, {}),
+            (7, {}),
+        ]
         assert sorted(G.nodes.data()) == nlist
         if G.is_directed():
-            elist = [(0, 1, {}), (0, 2, {}), (1, 0, {}), (1, 2, {}),
-                     (2, 0, {}), (2, 1, {}),
-                     (4, 5, {}), (6, 7, {'weight': 2})]
+            elist = [
+                (0, 1, {}),
+                (0, 2, {}),
+                (1, 0, {}),
+                (1, 2, {}),
+                (2, 0, {}),
+                (2, 1, {}),
+                (4, 5, {}),
+                (6, 7, {"weight": 2}),
+            ]
         else:
-            elist = [(0, 1, {}), (0, 2, {}), (1, 2, {}),
-                     (4, 5, {}), (6, 7, {'weight': 2})]
+            elist = [
+                (0, 1, {}),
+                (0, 2, {}),
+                (1, 2, {}),
+                (4, 5, {}),
+                (6, 7, {"weight": 2}),
+            ]
         assert sorted(G.edges.data()) == elist
         assert G.graph == {}
 
         # no keywords -- order is edges, nodes
         G = self.K3.copy()
-        G.update([(4, 5), (6, 7, {'weight': 2})], [3, (4, {'size': 2})])
+        G.update([(4, 5), (6, 7, {"weight": 2})], [3, (4, {"size": 2})])
         assert sorted(G.nodes.data()) == nlist
         assert sorted(G.edges.data()) == elist
         assert G.graph == {}
 
         # update using only a graph
         G = self.Graph()
-        G.graph['foo'] = 'bar'
+        G.graph["foo"] = "bar"
         G.add_node(2, data=4)
         G.add_edge(0, 1, weight=0.5)
         GG = G.copy()
@@ -701,10 +737,10 @@ class TestEdgeSubgraph:
         G = nx.path_graph(5)
         # Add some node, edge, and graph attributes.
         for i in range(5):
-            G.nodes[i]['name'] = f'node{i}'
-        G.edges[0, 1]['name'] = 'edge01'
-        G.edges[3, 4]['name'] = 'edge34'
-        G.graph['name'] = 'graph'
+            G.nodes[i]["name"] = f"node{i}"
+        G.edges[0, 1]["name"] = "edge01"
+        G.edges[3, 4]["name"] = "edge34"
+        G.graph["name"] = "graph"
         # Get the subgraph induced by the first and last edges.
         self.G = G
         self.H = G.edge_subgraph([(0, 1), (3, 4)])
@@ -715,8 +751,7 @@ class TestEdgeSubgraph:
 
     def test_correct_edges(self):
         """Tests that the subgraph has the correct edges."""
-        assert ([(0, 1, 'edge01'), (3, 4, 'edge34')] ==
-                sorted(self.H.edges(data='name')))
+        assert [(0, 1, "edge01"), (3, 4, "edge34")] == sorted(self.H.edges(data="name"))
 
     def test_add_node(self):
         """Tests that adding a node to the original graph does not
@@ -742,9 +777,9 @@ class TestEdgeSubgraph:
         for v in self.H:
             assert self.G.nodes[v] == self.H.nodes[v]
         # Making a change to G should make a change in H and vice versa.
-        self.G.nodes[0]['name'] = 'foo'
+        self.G.nodes[0]["name"] = "foo"
         assert self.G.nodes[0] == self.H.nodes[0]
-        self.H.nodes[1]['name'] = 'bar'
+        self.H.nodes[1]["name"] = "bar"
         assert self.G.nodes[1] == self.H.nodes[1]
 
     def test_edge_attr_dict(self):
@@ -755,12 +790,10 @@ class TestEdgeSubgraph:
         for u, v in self.H.edges():
             assert self.G.edges[u, v] == self.H.edges[u, v]
         # Making a change to G should make a change in H and vice versa.
-        self.G.edges[0, 1]['name'] = 'foo'
-        assert (self.G.edges[0, 1]['name'] ==
-                self.H.edges[0, 1]['name'])
-        self.H.edges[3, 4]['name'] = 'bar'
-        assert (self.G.edges[3, 4]['name'] ==
-                self.H.edges[3, 4]['name'])
+        self.G.edges[0, 1]["name"] = "foo"
+        assert self.G.edges[0, 1]["name"] == self.H.edges[0, 1]["name"]
+        self.H.edges[3, 4]["name"] = "bar"
+        assert self.G.edges[3, 4]["name"] == self.H.edges[3, 4]["name"]
 
     def test_graph_attr_dict(self):
         """Tests that the graph attribute dictionary of the two graphs
diff --git a/networkx/classes/tests/test_graph_historical.py b/networkx/classes/tests/test_graph_historical.py
index d0c45fa5..7af081c4 100644
--- a/networkx/classes/tests/test_graph_historical.py
+++ b/networkx/classes/tests/test_graph_historical.py
@@ -6,7 +6,6 @@ from .historical_tests import HistoricalTests
 
 
 class TestGraphHistorical(HistoricalTests):
-
     @classmethod
     def setup_class(cls):
         HistoricalTests.setup_class()
diff --git a/networkx/classes/tests/test_graphviews.py b/networkx/classes/tests/test_graphviews.py
index 376896d5..2fd8849f 100644
--- a/networkx/classes/tests/test_graphviews.py
+++ b/networkx/classes/tests/test_graphviews.py
@@ -13,6 +13,7 @@ class TestReverseView:
 
     def test_pickle(self):
         import pickle
+
         rv = self.rv
         prv = pickle.loads(pickle.dumps(rv, -1))
         assert rv._node == prv._node
@@ -35,7 +36,6 @@ class TestReverseView:
 
     def test_subclass(self):
         class MyGraph(nx.DiGraph):
-
             def my_method(self):
                 return "me"
 
@@ -61,6 +61,7 @@ class TestMultiReverseView:
 
     def test_pickle(self):
         import pickle
+
         rv = self.rv
         prv = pickle.loads(pickle.dumps(rv, -1))
         assert rv._node == prv._node
@@ -104,6 +105,7 @@ class TestToDirected:
 
     def test_pickle(self):
         import pickle
+
         dv = self.dv
         pdv = pickle.loads(pickle.dumps(dv, -1))
         assert dv._node == pdv._node
@@ -142,12 +144,13 @@ class TestToUndirected:
 
     def test_pickle(self):
         import pickle
+
         uv = self.uv
         puv = pickle.loads(pickle.dumps(uv, -1))
         assert uv._node == puv._node
         assert uv._adj == puv._adj
         assert uv.graph == puv.graph
-        assert hasattr(uv, '_graph')
+        assert hasattr(uv, "_graph")
 
     def test_contains(self):
         assert (2, 3) in self.DG.edges
@@ -173,14 +176,24 @@ class TestChainsOfViews:
         cls.MDGv = nx.to_directed(cls.MG)
         cls.Rv = cls.DG.reverse()
         cls.MRv = cls.MDG.reverse()
-        cls.graphs = [cls.G, cls.DG, cls.MG, cls.MDG,
-                      cls.Gv, cls.DGv, cls.MGv, cls.MDGv,
-                      cls.Rv, cls.MRv]
+        cls.graphs = [
+            cls.G,
+            cls.DG,
+            cls.MG,
+            cls.MDG,
+            cls.Gv,
+            cls.DGv,
+            cls.MGv,
+            cls.MDGv,
+            cls.Rv,
+            cls.MRv,
+        ]
         for G in cls.graphs:
             G.edges, G.nodes, G.degree
 
     def test_pickle(self):
         import pickle
+
         for G in self.graphs:
             H = pickle.loads(pickle.dumps(G, -1))
             assert_edges_equal(H.edges, G.edges)
@@ -278,42 +291,41 @@ class TestChainsOfViews:
         SG = G.subgraph([4, 5, 6])
         CSG = SG.copy(as_view=True)
         DCSG = SG.copy(as_view=False)
-        assert hasattr(CSG, '_graph')  # is a view
-        assert not hasattr(DCSG, '_graph')  # not a view
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
 
     def test_copy_disubgraph(self):
         G = self.DG.copy()
         SG = G.subgraph([4, 5, 6])
         CSG = SG.copy(as_view=True)
         DCSG = SG.copy(as_view=False)
-        assert hasattr(CSG, '_graph')  # is a view
-        assert not hasattr(DCSG, '_graph')  # not a view
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
 
     def test_copy_multidisubgraph(self):
         G = self.MDG.copy()
         SG = G.subgraph([4, 5, 6])
         CSG = SG.copy(as_view=True)
         DCSG = SG.copy(as_view=False)
-        assert hasattr(CSG, '_graph')  # is a view
-        assert not hasattr(DCSG, '_graph')  # not a view
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
 
     def test_copy_multisubgraph(self):
         G = self.MG.copy()
         SG = G.subgraph([4, 5, 6])
         CSG = SG.copy(as_view=True)
         DCSG = SG.copy(as_view=False)
-        assert hasattr(CSG, '_graph')  # is a view
-        assert not hasattr(DCSG, '_graph')  # not a view
+        assert hasattr(CSG, "_graph")  # is a view
+        assert not hasattr(DCSG, "_graph")  # not a view
 
     def test_copy_of_view(self):
         G = nx.OrderedMultiGraph(self.MGv)
-        assert G.__class__.__name__ == 'OrderedMultiGraph'
+        assert G.__class__.__name__ == "OrderedMultiGraph"
         G = G.copy(as_view=True)
-        assert G.__class__.__name__ == 'OrderedMultiGraph'
+        assert G.__class__.__name__ == "OrderedMultiGraph"
 
     def test_subclass(self):
         class MyGraph(nx.DiGraph):
-
             def my_method(self):
                 return "me"
 
diff --git a/networkx/classes/tests/test_multidigraph.py b/networkx/classes/tests/test_multidigraph.py
index dba835ab..2bf184c6 100644
--- a/networkx/classes/tests/test_multidigraph.py
+++ b/networkx/classes/tests/test_multidigraph.py
@@ -16,114 +16,135 @@ class BaseMultiDiGraphTester(BaseMultiGraphTester):
 
     def test_edges_data(self):
         G = self.K3
-        edges = [(0, 1, {}), (0, 2, {}), (1, 0, {}),
-                 (1, 2, {}), (2, 0, {}), (2, 1, {})]
+        edges = [(0, 1, {}), (0, 2, {}), (1, 0, {}), (1, 2, {}), (2, 0, {}), (2, 1, {})]
         assert sorted(G.edges(data=True)) == edges
         assert sorted(G.edges(0, data=True)) == [(0, 1, {}), (0, 2, {})]
         pytest.raises((KeyError, nx.NetworkXError), G.neighbors, -1)
 
     def test_edges_multi(self):
         G = self.K3
-        assert (sorted(G.edges()) ==
-                [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
         assert sorted(G.edges(0)) == [(0, 1), (0, 2)]
         G.add_edge(0, 1)
-        assert (sorted(G.edges()) ==
-                [(0, 1), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
 
     def test_out_edges(self):
         G = self.K3
-        assert (sorted(G.out_edges()) ==
-                [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
         assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)]
         pytest.raises((KeyError, nx.NetworkXError), G.out_edges, -1)
         assert sorted(G.out_edges(0, keys=True)) == [(0, 1, 0), (0, 2, 0)]
 
     def test_out_edges_multi(self):
         G = self.K3
-        assert (sorted(G.out_edges()) ==
-                [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
         assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)]
         G.add_edge(0, 1, 2)
-        assert (sorted(G.out_edges()) ==
-                [(0, 1), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.out_edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
 
     def test_out_edges_data(self):
         G = self.K3
         assert sorted(G.edges(0, data=True)) == [(0, 1, {}), (0, 2, {})]
         G.remove_edge(0, 1)
         G.add_edge(0, 1, data=1)
-        assert (sorted(G.edges(0, data=True)) ==
-                [(0, 1, {'data': 1}), (0, 2, {})])
-        assert (sorted(G.edges(0, data='data')) ==
-                [(0, 1, 1), (0, 2, None)])
-        assert (sorted(G.edges(0, data='data', default=-1)) ==
-                [(0, 1, 1), (0, 2, -1)])
+        assert sorted(G.edges(0, data=True)) == [(0, 1, {"data": 1}), (0, 2, {})]
+        assert sorted(G.edges(0, data="data")) == [(0, 1, 1), (0, 2, None)]
+        assert sorted(G.edges(0, data="data", default=-1)) == [(0, 1, 1), (0, 2, -1)]
 
     def test_in_edges(self):
         G = self.K3
-        assert (sorted(G.in_edges()) ==
-                [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.in_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
         assert sorted(G.in_edges(0)) == [(1, 0), (2, 0)]
         pytest.raises((KeyError, nx.NetworkXError), G.in_edges, -1)
         G.add_edge(0, 1, 2)
-        assert (sorted(G.in_edges()) ==
-                [(0, 1), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.in_edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
         assert sorted(G.in_edges(0, keys=True)) == [(1, 0, 0), (2, 0, 0)]
 
     def test_in_edges_no_keys(self):
         G = self.K3
-        assert (sorted(G.in_edges()) ==
-                [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
+        assert sorted(G.in_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
         assert sorted(G.in_edges(0)) == [(1, 0), (2, 0)]
         G.add_edge(0, 1, 2)
-        assert (sorted(G.in_edges()) ==
-                [(0, 1), (0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)])
-
-        assert (sorted(G.in_edges(data=True, keys=False)) ==
-                [(0, 1, {}), (0, 1, {}), (0, 2, {}), (1, 0, {}),
-                 (1, 2, {}), (2, 0, {}), (2, 1, {})])
+        assert sorted(G.in_edges()) == [
+            (0, 1),
+            (0, 1),
+            (0, 2),
+            (1, 0),
+            (1, 2),
+            (2, 0),
+            (2, 1),
+        ]
+
+        assert sorted(G.in_edges(data=True, keys=False)) == [
+            (0, 1, {}),
+            (0, 1, {}),
+            (0, 2, {}),
+            (1, 0, {}),
+            (1, 2, {}),
+            (2, 0, {}),
+            (2, 1, {}),
+        ]
 
     def test_in_edges_data(self):
         G = self.K3
-        assert (sorted(G.in_edges(0, data=True)) ==
-                [(1, 0, {}), (2, 0, {})])
+        assert sorted(G.in_edges(0, data=True)) == [(1, 0, {}), (2, 0, {})]
         G.remove_edge(1, 0)
         G.add_edge(1, 0, data=1)
-        assert (sorted(G.in_edges(0, data=True)) ==
-                [(1, 0, {'data': 1}), (2, 0, {})])
-        assert (sorted(G.in_edges(0, data='data')) ==
-                [(1, 0, 1), (2, 0, None)])
-        assert (sorted(G.in_edges(0, data='data', default=-1)) ==
-                [(1, 0, 1), (2, 0, -1)])
+        assert sorted(G.in_edges(0, data=True)) == [(1, 0, {"data": 1}), (2, 0, {})]
+        assert sorted(G.in_edges(0, data="data")) == [(1, 0, 1), (2, 0, None)]
+        assert sorted(G.in_edges(0, data="data", default=-1)) == [(1, 0, 1), (2, 0, -1)]
 
     def is_shallow(self, H, G):
         # graph
-        assert G.graph['foo'] == H.graph['foo']
-        G.graph['foo'].append(1)
-        assert G.graph['foo'] == H.graph['foo']
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] == H.graph["foo"]
         # node
-        assert G.nodes[0]['foo'] == H.nodes[0]['foo']
-        G.nodes[0]['foo'].append(1)
-        assert G.nodes[0]['foo'] == H.nodes[0]['foo']
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
         # edge
-        assert G[1][2][0]['foo'] == H[1][2][0]['foo']
-        G[1][2][0]['foo'].append(1)
-        assert G[1][2][0]['foo'] == H[1][2][0]['foo']
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
 
     def is_deep(self, H, G):
         # graph
-        assert G.graph['foo'] == H.graph['foo']
-        G.graph['foo'].append(1)
-        assert G.graph['foo'] != H.graph['foo']
+        assert G.graph["foo"] == H.graph["foo"]
+        G.graph["foo"].append(1)
+        assert G.graph["foo"] != H.graph["foo"]
         # node
-        assert G.nodes[0]['foo'] == H.nodes[0]['foo']
-        G.nodes[0]['foo'].append(1)
-        assert G.nodes[0]['foo'] != H.nodes[0]['foo']
+        assert G.nodes[0]["foo"] == H.nodes[0]["foo"]
+        G.nodes[0]["foo"].append(1)
+        assert G.nodes[0]["foo"] != H.nodes[0]["foo"]
         # edge
-        assert G[1][2][0]['foo'] == H[1][2][0]['foo']
-        G[1][2][0]['foo'].append(1)
-        assert G[1][2][0]['foo'] != H[1][2][0]['foo']
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] != H[1][2][0]["foo"]
 
     def test_to_undirected(self):
         # MultiDiGraph -> MultiGraph changes number of edges so it is
@@ -168,10 +189,8 @@ class BaseMultiDiGraphTester(BaseMultiGraphTester):
         assert G.degree(0) == 4
         assert list(G.degree(iter([0]))) == [(0, 4)]
         G.add_edge(0, 1, weight=0.3, other=1.2)
-        assert (sorted(G.degree(weight='weight')) ==
-                [(0, 4.3), (1, 4.3), (2, 4)])
-        assert (sorted(G.degree(weight='other')) ==
-                [(0, 5.2), (1, 5.2), (2, 4)])
+        assert sorted(G.degree(weight="weight")) == [(0, 4.3), (1, 4.3), (2, 4)]
+        assert sorted(G.degree(weight="other")) == [(0, 5.2), (1, 5.2), (2, 4)]
 
     def test_in_degree(self):
         G = self.K3
@@ -179,7 +198,7 @@ class BaseMultiDiGraphTester(BaseMultiGraphTester):
         assert dict(G.in_degree()) == {0: 2, 1: 2, 2: 2}
         assert G.in_degree(0) == 2
         assert list(G.in_degree(iter([0]))) == [(0, 2)]
-        assert G.in_degree(0, weight='weight') == 2
+        assert G.in_degree(0, weight="weight") == 2
 
     def test_out_degree(self):
         G = self.K3
@@ -187,15 +206,15 @@ class BaseMultiDiGraphTester(BaseMultiGraphTester):
         assert dict(G.out_degree()) == {0: 2, 1: 2, 2: 2}
         assert G.out_degree(0) == 2
         assert list(G.out_degree(iter([0]))) == [(0, 2)]
-        assert G.out_degree(0, weight='weight') == 2
+        assert G.out_degree(0, weight="weight") == 2
 
     def test_size(self):
         G = self.K3
         assert G.size() == 6
         assert G.number_of_edges() == 6
         G.add_edge(0, 1, weight=0.3, other=1.2)
-        assert round(G.size(weight='weight'), 2) == 6.3
-        assert round(G.size(weight='other'), 2) == 7.2
+        assert round(G.size(weight="weight"), 2) == 6.3
+        assert round(G.size(weight="other"), 2) == 7.2
 
     def test_to_undirected_reciprocal(self):
         G = self.Graph()
@@ -256,26 +275,30 @@ class TestMultiDiGraph(BaseMultiDiGraphTester, _TestMultiGraph):
 
     def test_add_edges_from(self):
         G = self.Graph()
-        G.add_edges_from([(0, 1), (0, 1, {'weight': 3})])
-        assert G._adj == {0: {1: {0: {}, 1: {'weight': 3}}}, 1: {}}
-        assert G._succ == {0: {1: {0: {}, 1: {'weight': 3}}}, 1: {}}
-        assert G._pred == {0: {}, 1: {0: {0: {}, 1: {'weight': 3}}}}
-
-        G.add_edges_from([(0, 1), (0, 1, {'weight': 3})], weight=2)
-        assert G._succ == {0: {1: {0: {},
-                                   1: {'weight': 3},
-                                   2: {'weight': 2},
-                                   3: {'weight': 3}}},
-                           1: {}}
-        assert G._pred == {0: {}, 1: {0: {0: {}, 1: {'weight': 3},
-                                          2: {'weight': 2},
-                                          3: {'weight': 3}}}}
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})])
+        assert G._adj == {0: {1: {0: {}, 1: {"weight": 3}}}, 1: {}}
+        assert G._succ == {0: {1: {0: {}, 1: {"weight": 3}}}, 1: {}}
+        assert G._pred == {0: {}, 1: {0: {0: {}, 1: {"weight": 3}}}}
+
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})], weight=2)
+        assert G._succ == {
+            0: {1: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+            1: {},
+        }
+        assert G._pred == {
+            0: {},
+            1: {0: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+        }
 
         G = self.Graph()
-        edges = [(0, 1, {'weight': 3}), (0, 1, (('weight', 2),)),
-                 (0, 1, 5), (0, 1, 's')]
+        edges = [
+            (0, 1, {"weight": 3}),
+            (0, 1, (("weight", 2),)),
+            (0, 1, 5),
+            (0, 1, "s"),
+        ]
         G.add_edges_from(edges)
-        keydict = {0: {'weight': 3}, 1: {'weight': 2}, 5: {}, 's': {}}
+        keydict = {0: {"weight": 3}, 1: {"weight": 2}, 5: {}, "s": {}}
         assert G._succ == {0: {1: keydict}, 1: {}}
         assert G._pred == {1: {0: keydict}, 0: {}}
 
@@ -289,49 +312,66 @@ class TestMultiDiGraph(BaseMultiDiGraphTester, _TestMultiGraph):
     def test_remove_edge(self):
         G = self.K3
         G.remove_edge(0, 1)
-        assert G._succ == {0: {2: {0: {}}},
-                           1: {0: {0: {}}, 2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
-        assert G._pred == {0: {1: {0: {}}, 2: {0: {}}},
-                           1: {2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
+        assert G._succ == {
+            0: {2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
         pytest.raises((KeyError, nx.NetworkXError), G.remove_edge, -1, 0)
-        pytest.raises((KeyError, nx.NetworkXError), G.remove_edge, 0, 2,
-                      key=1)
+        pytest.raises((KeyError, nx.NetworkXError), G.remove_edge, 0, 2, key=1)
 
     def test_remove_multiedge(self):
         G = self.K3
-        G.add_edge(0, 1, key='parallel edge')
-        G.remove_edge(0, 1, key='parallel edge')
-        assert G._adj == {0: {1: {0: {}}, 2: {0: {}}},
-                          1: {0: {0: {}}, 2: {0: {}}},
-                          2: {0: {0: {}}, 1: {0: {}}}}
-
-        assert G._succ == {0: {1: {0: {}}, 2: {0: {}}},
-                           1: {0: {0: {}}, 2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
-
-        assert G._pred == {0: {1: {0: {}}, 2: {0: {}}},
-                           1: {0: {0: {}}, 2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
+        G.add_edge(0, 1, key="parallel edge")
+        G.remove_edge(0, 1, key="parallel edge")
+        assert G._adj == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+
+        assert G._succ == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
         G.remove_edge(0, 1)
-        assert G._succ == {0: {2: {0: {}}},
-                           1: {0: {0: {}}, 2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
-        assert G._pred == {0: {1: {0: {}}, 2: {0: {}}},
-                           1: {2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
+        assert G._succ == {
+            0: {2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
         pytest.raises((KeyError, nx.NetworkXError), G.remove_edge, -1, 0)
 
     def test_remove_edges_from(self):
         G = self.K3
         G.remove_edges_from([(0, 1)])
-        assert G._succ == {0: {2: {0: {}}},
-                           1: {0: {0: {}}, 2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
-        assert G._pred == {0: {1: {0: {}}, 2: {0: {}}},
-                           1: {2: {0: {}}},
-                           2: {0: {0: {}}, 1: {0: {}}}}
+        assert G._succ == {
+            0: {2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
+        assert G._pred == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
         G.remove_edges_from([(0, 0)])  # silent fail
 
 
@@ -347,12 +387,12 @@ class TestEdgeSubgraph(_TestMultiGraphEdgeSubgraph):
         nx.add_path(G, reversed(range(5)))
         # Add some node, edge, and graph attributes.
         for i in range(5):
-            G.nodes[i]['name'] = f'node{i}'
-        G.adj[0][1][0]['name'] = 'edge010'
-        G.adj[0][1][1]['name'] = 'edge011'
-        G.adj[3][4][0]['name'] = 'edge340'
-        G.adj[3][4][1]['name'] = 'edge341'
-        G.graph['name'] = 'graph'
+            G.nodes[i]["name"] = f"node{i}"
+        G.adj[0][1][0]["name"] = "edge010"
+        G.adj[0][1][1]["name"] = "edge011"
+        G.adj[3][4][0]["name"] = "edge340"
+        G.adj[3][4][1]["name"] = "edge341"
+        G.graph["name"] = "graph"
         # Get the subgraph induced by one of the first edges and one of
         # the last edges.
         self.G = G
diff --git a/networkx/classes/tests/test_multigraph.py b/networkx/classes/tests/test_multigraph.py
index fb409efd..5fee1897 100644
--- a/networkx/classes/tests/test_multigraph.py
+++ b/networkx/classes/tests/test_multigraph.py
@@ -25,20 +25,21 @@ class BaseMultiGraphTester(BaseAttrGraphTester):
 
     def test_adjacency(self):
         G = self.K3
-        assert (dict(G.adjacency()) ==
-                {0: {1: {0: {}}, 2: {0: {}}},
-                 1: {0: {0: {}}, 2: {0: {}}},
-                 2: {0: {0: {}}, 1: {0: {}}}})
+        assert dict(G.adjacency()) == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
 
     def deepcopy_edge_attr(self, H, G):
-        assert G[1][2][0]['foo'] == H[1][2][0]['foo']
-        G[1][2][0]['foo'].append(1)
-        assert G[1][2][0]['foo'] != H[1][2][0]['foo']
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] != H[1][2][0]["foo"]
 
     def shallow_copy_edge_attr(self, H, G):
-        assert G[1][2][0]['foo'] == H[1][2][0]['foo']
-        G[1][2][0]['foo'].append(1)
-        assert G[1][2][0]['foo'] == H[1][2][0]['foo']
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
+        G[1][2][0]["foo"].append(1)
+        assert G[1][2][0]["foo"] == H[1][2][0]["foo"]
 
     def graphs_equal(self, H, G):
         assert G._adj == H._adj
@@ -62,30 +63,30 @@ class BaseMultiGraphTester(BaseAttrGraphTester):
 
     def same_attrdict(self, H, G):
         # same attrdict in the edgedata
-        old_foo = H[1][2][0]['foo']
-        H.adj[1][2][0]['foo'] = 'baz'
+        old_foo = H[1][2][0]["foo"]
+        H.adj[1][2][0]["foo"] = "baz"
         assert G._adj == H._adj
-        H.adj[1][2][0]['foo'] = old_foo
+        H.adj[1][2][0]["foo"] = old_foo
         assert G._adj == H._adj
 
-        old_foo = H.nodes[0]['foo']
-        H.nodes[0]['foo'] = 'baz'
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
         assert G._node == H._node
-        H.nodes[0]['foo'] = old_foo
+        H.nodes[0]["foo"] = old_foo
         assert G._node == H._node
 
     def different_attrdict(self, H, G):
         # used by graph_equal_but_different
-        old_foo = H[1][2][0]['foo']
-        H.adj[1][2][0]['foo'] = 'baz'
+        old_foo = H[1][2][0]["foo"]
+        H.adj[1][2][0]["foo"] = "baz"
         assert G._adj != H._adj
-        H.adj[1][2][0]['foo'] = old_foo
+        H.adj[1][2][0]["foo"] = old_foo
         assert G._adj == H._adj
 
-        old_foo = H.nodes[0]['foo']
-        H.nodes[0]['foo'] = 'baz'
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
         assert G._node != H._node
-        H.nodes[0]['foo'] = old_foo
+        H.nodes[0]["foo"] = old_foo
         assert G._node == H._node
 
     def test_to_undirected(self):
@@ -108,39 +109,56 @@ class BaseMultiGraphTester(BaseAttrGraphTester):
         G = self.K3
         G.add_edge(0, 0)
         G.add_edge(0, 0)
-        G.add_edge(0, 0, key='parallel edge')
-        G.remove_edge(0, 0, key='parallel edge')
+        G.add_edge(0, 0, key="parallel edge")
+        G.remove_edge(0, 0, key="parallel edge")
         assert G.number_of_edges(0, 0) == 2
         G.remove_edge(0, 0)
         assert G.number_of_edges(0, 0) == 1
 
     def test_edge_lookup(self):
         G = self.Graph()
-        G.add_edge(1, 2, foo='bar')
-        G.add_edge(1, 2, 'key', foo='biz')
-        assert_edges_equal(G.edges[1, 2, 0], {'foo': 'bar'})
-        assert_edges_equal(G.edges[1, 2, 'key'], {'foo': 'biz'})
+        G.add_edge(1, 2, foo="bar")
+        G.add_edge(1, 2, "key", foo="biz")
+        assert_edges_equal(G.edges[1, 2, 0], {"foo": "bar"})
+        assert_edges_equal(G.edges[1, 2, "key"], {"foo": "biz"})
 
     def test_edge_attr4(self):
         G = self.Graph()
-        G.add_edge(1, 2, key=0, data=7, spam='bar', bar='foo')
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 7, 'spam': 'bar', 'bar': 'foo'})])
-        G[1][2][0]['data'] = 10  # OK to set data like this
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 10, 'spam': 'bar', 'bar': 'foo'})])
-
-        G.adj[1][2][0]['data'] = 20
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 20, 'spam': 'bar', 'bar': 'foo'})])
-        G.edges[1, 2, 0]['data'] = 21  # another spelling, "edge"
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 21, 'spam': 'bar', 'bar': 'foo'})])
-        G.adj[1][2][0]['listdata'] = [20, 200]
-        G.adj[1][2][0]['weight'] = 20
-        assert_edges_equal(G.edges(data=True),
-                           [(1, 2, {'data': 21, 'spam': 'bar', 'bar': 'foo',
-                                    'listdata': [20, 200], 'weight':20})])
+        G.add_edge(1, 2, key=0, data=7, spam="bar", bar="foo")
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 7, "spam": "bar", "bar": "foo"})]
+        )
+        G[1][2][0]["data"] = 10  # OK to set data like this
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 10, "spam": "bar", "bar": "foo"})]
+        )
+
+        G.adj[1][2][0]["data"] = 20
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 20, "spam": "bar", "bar": "foo"})]
+        )
+        G.edges[1, 2, 0]["data"] = 21  # another spelling, "edge"
+        assert_edges_equal(
+            G.edges(data=True), [(1, 2, {"data": 21, "spam": "bar", "bar": "foo"})]
+        )
+        G.adj[1][2][0]["listdata"] = [20, 200]
+        G.adj[1][2][0]["weight"] = 20
+        assert_edges_equal(
+            G.edges(data=True),
+            [
+                (
+                    1,
+                    2,
+                    {
+                        "data": 21,
+                        "spam": "bar",
+                        "bar": "foo",
+                        "listdata": [20, 200],
+                        "weight": 20,
+                    },
+                )
+            ],
+        )
 
 
 class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
@@ -148,9 +166,7 @@ class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
         self.Graph = nx.MultiGraph
         # build K3
         ed1, ed2, ed3 = ({0: {}}, {0: {}}, {0: {}})
-        self.k3adj = {0: {1: ed1, 2: ed2},
-                      1: {0: ed1, 2: ed3},
-                      2: {0: ed2, 1: ed3}}
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed1, 2: ed3}, 2: {0: ed2, 1: ed3}}
         self.k3edges = [(0, 1), (0, 2), (1, 2)]
         self.k3nodes = [0, 1, 2]
         self.K3 = self.Graph()
@@ -170,9 +186,9 @@ class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
         G = self.K3
         assert G[0] == {1: {0: {}}, 2: {0: {}}}
         with pytest.raises(KeyError):
-            G.__getitem__('j')
+            G.__getitem__("j")
         with pytest.raises(TypeError):
-            G.__getitem__(['A'])
+            G.__getitem__(["A"])
 
     def test_remove_node(self):
         G = self.K3
@@ -201,19 +217,25 @@ class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
 
     def test_add_edges_from(self):
         G = self.Graph()
-        G.add_edges_from([(0, 1), (0, 1, {'weight': 3})])
-        assert G.adj == {0: {1: {0: {}, 1: {'weight': 3}}},
-                         1: {0: {0: {}, 1: {'weight': 3}}}}
-        G.add_edges_from([(0, 1), (0, 1, {'weight': 3})], weight=2)
-        assert G.adj == {0: {1: {0: {}, 1: {'weight': 3},
-                                 2: {'weight': 2}, 3: {'weight': 3}}},
-                         1: {0: {0: {}, 1: {'weight': 3},
-                                 2: {'weight': 2}, 3: {'weight': 3}}}}
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})])
+        assert G.adj == {
+            0: {1: {0: {}, 1: {"weight": 3}}},
+            1: {0: {0: {}, 1: {"weight": 3}}},
+        }
+        G.add_edges_from([(0, 1), (0, 1, {"weight": 3})], weight=2)
+        assert G.adj == {
+            0: {1: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+            1: {0: {0: {}, 1: {"weight": 3}, 2: {"weight": 2}, 3: {"weight": 3}}},
+        }
         G = self.Graph()
-        edges = [(0, 1, {'weight': 3}), (0, 1, (('weight', 2),)),
-                 (0, 1, 5), (0, 1, 's')]
+        edges = [
+            (0, 1, {"weight": 3}),
+            (0, 1, (("weight", 2),)),
+            (0, 1, 5),
+            (0, 1, "s"),
+        ]
         G.add_edges_from(edges)
-        keydict = {0: {'weight': 3}, 1: {'weight': 2}, 5: {}, 's': {}}
+        keydict = {0: {"weight": 3}, 1: {"weight": 2}, 5: {}, "s": {}}
         assert G._adj == {0: {1: keydict}, 1: {0: keydict}}
 
         # too few in tuple
@@ -229,10 +251,7 @@ class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
     def test_remove_edge(self):
         G = self.K3
         G.remove_edge(0, 1)
-        assert G.adj == {0: {2: {0: {}}},
-                         1: {2: {0: {}}},
-                         2: {0: {0: {}},
-                             1: {0: {}}}}
+        assert G.adj == {0: {2: {0: {}}}, 1: {2: {0: {}}}, 2: {0: {0: {}}, 1: {0: {}}}}
 
         with pytest.raises(nx.NetworkXError):
             G.remove_edge(-1, 0)
@@ -261,11 +280,13 @@ class TestMultiGraph(BaseMultiGraphTester, _TestGraph):
 
     def test_remove_multiedge(self):
         G = self.K3
-        G.add_edge(0, 1, key='parallel edge')
-        G.remove_edge(0, 1, key='parallel edge')
-        assert G.adj == {0: {1: {0: {}}, 2: {0: {}}},
-                         1: {0: {0: {}}, 2: {0: {}}},
-                         2: {0: {0: {}}, 1: {0: {}}}}
+        G.add_edge(0, 1, key="parallel edge")
+        G.remove_edge(0, 1, key="parallel edge")
+        assert G.adj == {
+            0: {1: {0: {}}, 2: {0: {}}},
+            1: {0: {0: {}}, 2: {0: {}}},
+            2: {0: {0: {}}, 1: {0: {}}},
+        }
         G.remove_edge(0, 1)
         kd = {0: {}}
         assert G.adj == {0: {2: kd}, 1: {2: kd}, 2: {0: kd, 1: kd}}
@@ -283,12 +304,12 @@ class TestEdgeSubgraph:
         nx.add_path(G, range(5))
         # Add some node, edge, and graph attributes.
         for i in range(5):
-            G.nodes[i]['name'] = f'node{i}'
-        G.adj[0][1][0]['name'] = 'edge010'
-        G.adj[0][1][1]['name'] = 'edge011'
-        G.adj[3][4][0]['name'] = 'edge340'
-        G.adj[3][4][1]['name'] = 'edge341'
-        G.graph['name'] = 'graph'
+            G.nodes[i]["name"] = f"node{i}"
+        G.adj[0][1][0]["name"] = "edge010"
+        G.adj[0][1][1]["name"] = "edge011"
+        G.adj[3][4][0]["name"] = "edge340"
+        G.adj[3][4][1]["name"] = "edge341"
+        G.graph["name"] = "graph"
         # Get the subgraph induced by one of the first edges and one of
         # the last edges.
         self.G = G
@@ -300,8 +321,9 @@ class TestEdgeSubgraph:
 
     def test_correct_edges(self):
         """Tests that the subgraph has the correct edges."""
-        assert ([(0, 1, 0, 'edge010'), (3, 4, 1, 'edge341')] ==
-                sorted(self.H.edges(keys=True, data='name')))
+        assert [(0, 1, 0, "edge010"), (3, 4, 1, "edge341")] == sorted(
+            self.H.edges(keys=True, data="name")
+        )
 
     def test_add_node(self):
         """Tests that adding a node to the original graph does not
@@ -327,9 +349,9 @@ class TestEdgeSubgraph:
         for v in self.H:
             assert self.G.nodes[v] == self.H.nodes[v]
         # Making a change to G should make a change in H and vice versa.
-        self.G.nodes[0]['name'] = 'foo'
+        self.G.nodes[0]["name"] = "foo"
         assert self.G.nodes[0] == self.H.nodes[0]
-        self.H.nodes[1]['name'] = 'bar'
+        self.H.nodes[1]["name"] = "bar"
         assert self.G.nodes[1] == self.H.nodes[1]
 
     def test_edge_attr_dict(self):
@@ -340,12 +362,10 @@ class TestEdgeSubgraph:
         for u, v, k in self.H.edges(keys=True):
             assert self.G._adj[u][v][k] == self.H._adj[u][v][k]
         # Making a change to G should make a change in H and vice versa.
-        self.G._adj[0][1][0]['name'] = 'foo'
-        assert (self.G._adj[0][1][0]['name'] ==
-                self.H._adj[0][1][0]['name'])
-        self.H._adj[3][4][1]['name'] = 'bar'
-        assert (self.G._adj[3][4][1]['name'] ==
-                self.H._adj[3][4][1]['name'])
+        self.G._adj[0][1][0]["name"] = "foo"
+        assert self.G._adj[0][1][0]["name"] == self.H._adj[0][1][0]["name"]
+        self.H._adj[3][4][1]["name"] = "bar"
+        assert self.G._adj[3][4][1]["name"] == self.H._adj[3][4][1]["name"]
 
     def test_graph_attr_dict(self):
         """Tests that the graph attribute dictionary of the two graphs
diff --git a/networkx/classes/tests/test_special.py b/networkx/classes/tests/test_special.py
index 1db0d86e..cb0142e7 100644
--- a/networkx/classes/tests/test_special.py
+++ b/networkx/classes/tests/test_special.py
@@ -32,6 +32,7 @@ def test_factories():
             adjlist_inner_dict_factory = mydict3
             edge_key_dict_factory = mydict4
             edge_attr_dict_factory = mydict5
+
         G = MyGraph()
         assert isinstance(G._node, mydict1)
         assert isinstance(G._adj, mydict2)
@@ -64,21 +65,22 @@ class TestOrderedGraph(_TestGraph):
             adjlist_outer_dict_factory = OrderedDict
             adjlist_inner_dict_factory = OrderedDict
             edge_attr_dict_factory = OrderedDict
+
         self.Graph = MyGraph
 
 
 class TestThinGraph(BaseGraphTester):
     def setup_method(self):
-        all_edge_dict = {'weight': 1}
+        all_edge_dict = {"weight": 1}
 
         class MyGraph(nx.Graph):
-            def edge_attr_dict_factory(self): return all_edge_dict
+            def edge_attr_dict_factory(self):
+                return all_edge_dict
+
         self.Graph = MyGraph
         # build dict-of-dict-of-dict K3
         ed1, ed2, ed3 = (all_edge_dict, all_edge_dict, all_edge_dict)
-        self.k3adj = {0: {1: ed1, 2: ed2},
-                      1: {0: ed1, 2: ed3},
-                      2: {0: ed2, 1: ed3}}
+        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed1, 2: ed3}, 2: {0: ed2, 1: ed3}}
         self.k3edges = [(0, 1), (0, 2), (1, 2)]
         self.k3nodes = [0, 1, 2]
         self.K3 = self.Graph()
@@ -104,15 +106,18 @@ class TestOrderedDiGraph(_TestDiGraph):
             adjlist_outer_dict_factory = OrderedDict
             adjlist_inner_dict_factory = OrderedDict
             edge_attr_dict_factory = OrderedDict
+
         self.Graph = MyGraph
 
 
 class TestThinDiGraph(BaseDiGraphTester):
     def setup_method(self):
-        all_edge_dict = {'weight': 1}
+        all_edge_dict = {"weight": 1}
 
         class MyGraph(nx.DiGraph):
-            def edge_attr_dict_factory(self): return all_edge_dict
+            def edge_attr_dict_factory(self):
+                return all_edge_dict
+
         self.Graph = MyGraph
         # build dict-of-dict-of-dict K3
         ed1, ed2, ed3 = (all_edge_dict, all_edge_dict, all_edge_dict)
@@ -155,6 +160,7 @@ class TestOrderedMultiGraph(_TestMultiGraph):
             adjlist_inner_dict_factory = OrderedDict
             edge_key_dict_factory = OrderedDict
             edge_attr_dict_factory = OrderedDict
+
         self.Graph = MyGraph
 
 
@@ -174,4 +180,5 @@ class TestOrderedMultiDiGraph(_TestMultiDiGraph):
             adjlist_inner_dict_factory = OrderedDict
             edge_key_dict_factory = OrderedDict
             edge_attr_dict_factory = OrderedDict
+
         self.Graph = MyGraph
diff --git a/networkx/classes/tests/test_subgraphviews.py b/networkx/classes/tests/test_subgraphviews.py
index 825af4cc..bcfeea54 100644
--- a/networkx/classes/tests/test_subgraphviews.py
+++ b/networkx/classes/tests/test_subgraphviews.py
@@ -213,8 +213,8 @@ class TestInducedSubGraph:
     @classmethod
     def setup_class(cls):
         cls.K3 = G = nx.complete_graph(3)
-        G.graph['foo'] = []
-        G.nodes[0]['foo'] = []
+        G.graph["foo"] = []
+        G.nodes[0]["foo"] = []
         G.remove_edge(1, 2)
         ll = []
         G.add_edge(1, 2, foo=ll)
@@ -237,15 +237,15 @@ class TestInducedSubGraph:
         assert dict(H.adj) == {0: {1: {}}, 1: {0: {}}}
 
     def same_attrdict(self, H, G):
-        old_foo = H[1][2]['foo']
-        H.edges[1, 2]['foo'] = 'baz'
+        old_foo = H[1][2]["foo"]
+        H.edges[1, 2]["foo"] = "baz"
         assert G.edges == H.edges
-        H.edges[1, 2]['foo'] = old_foo
+        H.edges[1, 2]["foo"] = old_foo
         assert G.edges == H.edges
-        old_foo = H.nodes[0]['foo']
-        H.nodes[0]['foo'] = 'baz'
+        old_foo = H.nodes[0]["foo"]
+        H.nodes[0]["foo"] = "baz"
         assert G.nodes == H.nodes
-        H.nodes[0]['foo'] = old_foo
+        H.nodes[0]["foo"] = old_foo
         assert G.nodes == H.nodes
 
     def graphs_equal(self, H, G):
@@ -277,10 +277,10 @@ class TestEdgeSubGraph:
         cls.G = G = nx.path_graph(5)
         # Add some node, edge, and graph attributes.
         for i in range(5):
-            G.nodes[i]['name'] = f'node{i}'
-        G.edges[0, 1]['name'] = 'edge01'
-        G.edges[3, 4]['name'] = 'edge34'
-        G.graph['name'] = 'graph'
+            G.nodes[i]["name"] = f"node{i}"
+        G.edges[0, 1]["name"] = "edge01"
+        G.edges[3, 4]["name"] = "edge34"
+        G.graph["name"] = "graph"
         # Get the subgraph induced by the first and last edges.
         cls.H = nx.edge_subgraph(G, [(0, 1), (3, 4)])
 
@@ -290,8 +290,7 @@ class TestEdgeSubGraph:
 
     def test_correct_edges(self):
         """Tests that the subgraph has the correct edges."""
-        assert ([(0, 1, 'edge01'), (3, 4, 'edge34')] ==
-                sorted(self.H.edges(data='name')))
+        assert [(0, 1, "edge01"), (3, 4, "edge34")] == sorted(self.H.edges(data="name"))
 
     def test_add_node(self):
         """Tests that adding a node to the original graph does not
@@ -319,9 +318,9 @@ class TestEdgeSubGraph:
         for v in self.H:
             assert self.G.nodes[v] == self.H.nodes[v]
         # Making a change to G should make a change in H and vice versa.
-        self.G.nodes[0]['name'] = 'foo'
+        self.G.nodes[0]["name"] = "foo"
         assert self.G.nodes[0] == self.H.nodes[0]
-        self.H.nodes[1]['name'] = 'bar'
+        self.H.nodes[1]["name"] = "bar"
         assert self.G.nodes[1] == self.H.nodes[1]
 
     def test_edge_attr_dict(self):
@@ -332,12 +331,10 @@ class TestEdgeSubGraph:
         for u, v in self.H.edges():
             assert self.G.edges[u, v] == self.H.edges[u, v]
         # Making a change to G should make a change in H and vice versa.
-        self.G.edges[0, 1]['name'] = 'foo'
-        assert (self.G.edges[0, 1]['name'] ==
-                self.H.edges[0, 1]['name'])
-        self.H.edges[3, 4]['name'] = 'bar'
-        assert (self.G.edges[3, 4]['name'] ==
-                self.H.edges[3, 4]['name'])
+        self.G.edges[0, 1]["name"] = "foo"
+        assert self.G.edges[0, 1]["name"] == self.H.edges[0, 1]["name"]
+        self.H.edges[3, 4]["name"] = "bar"
+        assert self.G.edges[3, 4]["name"] == self.H.edges[3, 4]["name"]
 
     def test_graph_attr_dict(self):
         """Tests that the graph attribute dictionary of the two graphs