def test_read_sparse6(self):
data = b':Q___eDcdFcDeFcE`GaJ`IaHbKNbLM'
G = nx.from_sparse6_bytes(data)
fh = BytesIO(data)
Gin = nx.read_sparse6(fh)
assert_nodes_equal(G.nodes(), Gin.nodes())
assert_edges_equal(G.edges(), Gin.edges())
def test_add_star(self):
G = self.G.copy()
nlist = [12, 13, 14, 15]
nx.add_star(G, nlist)
assert_edges_equal(G.edges(nlist), [(12, 13), (12, 14), (12, 15)])
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.
})])
G = self.G.copy()
nlist = [12]
nx.add_star(G, nlist)
assert_nodes_equal(G, list(self.G) + nlist)
G = self.G.copy()
nlist = []
nx.add_star(G, nlist)
assert_nodes_equal(G.nodes, self.Gnodes)
assert_edges_equal(G.edges, self.G.edges)
def test_write_read_attribute_numeric_type_graphml(self):
from xml.etree.ElementTree import parse
G = self.attribute_numeric_type_graph
fh = io.BytesIO()
self.writer(G, fh, infer_numeric_types=True)
fh.seek(0)
H = nx.read_graphml(fh)
fh.seek(0)
assert_nodes_equal(G.nodes(), H.nodes())
assert_edges_equal(G.edges(), H.edges())
assert_edges_equal(G.edges(data=True), H.edges(data=True))
self.attribute_numeric_type_fh.seek(0)
xml = parse(fh)
# Children are the key elements, and the graph element
children = list(xml.getroot())
assert len(children) == 3
keys = [child.items() for child in children[:2]]
assert len(keys) == 2
assert ("attr.type", "double") in keys[0]
assert ("attr.type", "double") in keys[1]
def test_read_sparse6(self):
data = b':Q___eDcdFcDeFcE`GaJ`IaHbKNbLM'
G = nx.from_sparse6_bytes(data)
fh = BytesIO(data)
Gin = nx.read_sparse6(fh)
assert_nodes_equal(G.nodes(), Gin.nodes())
assert_edges_equal(G.edges(), Gin.edges())
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)]]
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.})]]
nx.add_cycle(G, nlist, weight=1.0)
assert sorted(G.edges(nlist, data=True)) in oklists
G = self.G.copy()
nlist = [12]
nx.add_cycle(G, nlist)
assert_nodes_equal(G, list(self.G) + nlist)
G = self.G.copy()
nlist = []
nx.add_cycle(G, nlist)
assert_nodes_equal(G.nodes, self.Gnodes)
assert_edges_equal(G.edges, self.G.edges)
def test_node_attr2(self):
G = self.K3.copy()
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'})])
def test_read_equals_from_bytes(self):
data = b'DF{'
G = nx.from_graph6_bytes(data)
fh = BytesIO(data)
Gin = nx.read_graph6(fh)
assert_nodes_equal(G.nodes(), Gin.nodes())
assert_edges_equal(G.edges(), Gin.edges())
def test_selfloops(graph_type):
G = nx.complete_graph(3, create_using=graph_type)
G.add_edge(0, 0)
assert_nodes_equal(nx.nodes_with_selfloops(G), [0])
assert_edges_equal(nx.selfloop_edges(G), [(0, 0)])
assert_edges_equal(nx.selfloop_edges(G, data=True), [(0, 0, {})])
assert nx.number_of_selfloops(G) == 1
def test_roundtrip(self):
for i in list(range(13)) + [31, 47, 62, 63, 64, 72]:
G = nx.random_graphs.gnm_random_graph(i, i * i // 4, seed=i)
f = BytesIO()
nx.write_graph6(G, f)
f.seek(0)
H = nx.read_graph6(f)
assert_nodes_equal(G.nodes(), H.nodes())
assert_edges_equal(G.edges(), H.edges())
def test_path__partition_provided_as_dict_of_sets(self):
G = nx.path_graph(6)
partition = {0: {0, 1}, 2: {2, 3}, 4: {4, 5}}
M = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(M, [0, 1, 2])
assert_edges_equal(M.edges(), [(0, 1), (1, 2)])
for n in M:
assert M.nodes[n]["nedges"] == 1
assert M.nodes[n]["nnodes"] == 2
assert M.nodes[n]["density"] == 1
def test_blockmodel(self):
G = nx.path_graph(6)
partition = [[0, 1], [2, 3], [4, 5]]
M = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(M.nodes(), [0, 1, 2])
assert_edges_equal(M.edges(), [(0, 1), (1, 2)])
for n in M.nodes():
assert M.nodes[n]['nedges'] == 1
assert M.nodes[n]['nnodes'] == 2
assert M.nodes[n]['density'] == 1.0
def test_read_simple_undirected_graphml(self):
G = self.simple_undirected_graph
H = nx.read_graphml(self.simple_undirected_fh)
assert_nodes_equal(G.nodes(), H.nodes())
assert_edges_equal(G.edges(), H.edges())
self.simple_undirected_fh.seek(0)
I = nx.parse_graphml(self.simple_undirected_data)
assert_nodes_equal(G.nodes(), I.nodes())
assert_edges_equal(G.edges(), I.edges())
def test_multigraph_path(self):
G = nx.MultiGraph(nx.path_graph(6))
partition = [{0, 1}, {2, 3}, {4, 5}]
M = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(M, [0, 1, 2])
assert_edges_equal(M.edges(), [(0, 1), (1, 2)])
for n in M:
assert M.nodes[n]["nedges"] == 1
assert M.nodes[n]["nnodes"] == 2
assert M.nodes[n]["density"] == 1
def test_barbell(self):
G = nx.barbell_graph(3, 0)
partition = [{0, 1, 2}, {3, 4, 5}]
M = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(M, [0, 1])
assert_edges_equal(M.edges(), [(0, 1)])
for n in M:
assert M.nodes[n]["nedges"] == 3
assert M.nodes[n]["nnodes"] == 3
assert M.nodes[n]["density"] == 1
def test_multigraph_blockmodel(self):
G = nx.MultiGraph(nx.path_graph(6))
partition = [[0, 1], [2, 3], [4, 5]]
M = nx.quotient_graph(G, partition, create_using=nx.MultiGraph(), relabel=True)
assert_nodes_equal(M.nodes(), [0, 1, 2])
assert_edges_equal(M.edges(), [(0, 1), (1, 2)])
for n in M.nodes():
assert M.nodes[n]["nedges"] == 1
assert M.nodes[n]["nnodes"] == 2
assert M.nodes[n]["density"] == 1.0
def test_read_many_graph6(self):
# Read many graphs into list
data = (b':Q___eDcdFcDeFcE`GaJ`IaHbKNbLM\n'
b':Q___dCfDEdcEgcbEGbFIaJ`JaHN`IM')
fh = BytesIO(data)
glist = nx.read_sparse6(fh)
assert len(glist) == 2
for G in glist:
assert_nodes_equal(
G.nodes(),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17])
def test_read_many_graph6(self):
# Read many graphs into list
data = (b':Q___eDcdFcDeFcE`GaJ`IaHbKNbLM\n'
b':Q___dCfDEdcEgcbEGbFIaJ`JaHN`IM')
fh = BytesIO(data)
glist = nx.read_sparse6(fh)
assert_equal(len(glist), 2)
for G in glist:
assert_nodes_equal(G.nodes(),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17])
def test_quotient_graph_incomplete_partition(self):
G = nx.path_graph(6)
partition = []
H = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(H.nodes(), [])
assert_edges_equal(H.edges(), [])
partition = [[0, 1], [2, 3], [5]]
H = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(H.nodes(), [0, 1, 2])
assert_edges_equal(H.edges(), [(0, 1)])
def test_create_empty_copy(self):
G = nx.create_empty_copy(self.G, with_data=False)
assert_nodes_equal(G, list(self.G))
assert G.graph == {}
assert G._node == {}.fromkeys(self.G.nodes(), {})
assert G._adj == {}.fromkeys(self.G.nodes(), {})
G = nx.create_empty_copy(self.G)
assert_nodes_equal(G, list(self.G))
assert G.graph == self.G.graph
assert G._node == self.G._node
assert G._adj == {}.fromkeys(self.G.nodes(), {})
def test_directed_path(self):
G = nx.DiGraph()
nx.add_path(G, range(6))
partition = [{0, 1}, {2, 3}, {4, 5}]
M = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(M, [0, 1, 2])
assert_edges_equal(M.edges(), [(0, 1), (1, 2)])
for n in M:
assert M.nodes[n]["nedges"] == 1
assert M.nodes[n]["nnodes"] == 2
assert M.nodes[n]["density"] == 0.5
def test_from_sparse6_bytes(self):
data = b':Q___eDcdFcDeFcE`GaJ`IaHbKNbLM'
G = nx.from_sparse6_bytes(data)
assert_nodes_equal(
sorted(G.nodes()),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17])
assert_edges_equal(G.edges(),
[(0, 1), (0, 2), (0, 3), (1, 12), (1, 14), (2, 13),
(2, 15), (3, 16), (3, 17), (4, 7), (4, 9), (4, 11),
(5, 6), (5, 8), (5, 9), (6, 10), (6, 11), (7, 8),
(7, 10), (8, 12), (9, 15), (10, 14), (11, 13),
(12, 16), (13, 17), (14, 17), (15, 16)])
def test_from_sparse6_bytes(self):
data = b':Q___eDcdFcDeFcE`GaJ`IaHbKNbLM'
G = nx.from_sparse6_bytes(data)
assert_nodes_equal(sorted(G.nodes()),
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17])
assert_edges_equal(G.edges(),
[(0, 1), (0, 2), (0, 3), (1, 12), (1, 14), (2, 13),
(2, 15), (3, 16), (3, 17), (4, 7), (4, 9), (4, 11),
(5, 6), (5, 8), (5, 9), (6, 10), (6, 11), (7, 8),
(7, 10), (8, 12), (9, 15), (10, 14), (11, 13),
(12, 16), (13, 17), (14, 17), (15, 16)])
def test_protocol(self):
for G in [self.G, self.DG, self.MG, self.MDG,
self.fG, self.fDG, self.fMG, self.fMDG]:
with tempfile.TemporaryFile() as f:
nx.write_gpickle(G, f, 0)
f.seek(0)
Gin = nx.read_gpickle(f)
assert_nodes_equal(list(G.nodes(data=True)),
list(Gin.nodes(data=True)))
assert_edges_equal(list(G.edges(data=True)),
list(Gin.edges(data=True)))
assert_graphs_equal(G, Gin)
def test_barbell_plus(self):
G = nx.barbell_graph(3, 0)
# Add an extra edge joining the bells.
G.add_edge(0, 5)
partition = [{0, 1, 2}, {3, 4, 5}]
M = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(M, [0, 1])
assert_edges_equal(M.edges(), [(0, 1)])
assert M[0][1]["weight"] == 2
for n in M:
assert M.nodes[n]["nedges"] == 3
assert M.nodes[n]["nnodes"] == 3
assert M.nodes[n]["density"] == 1
def test_weighted_degree(self):
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_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 test_node_attr(self):
G = self.K3.copy()
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')])
def test_gpickle(self):
for G in [self.G, self.DG, self.MG, self.MDG,
self.fG, self.fDG, self.fMG, self.fMDG]:
(fd, fname) = tempfile.mkstemp()
nx.write_gpickle(G, fname)
Gin = nx.read_gpickle(fname)
assert_nodes_equal(list(G.nodes(data=True)),
list(Gin.nodes(data=True)))
assert_edges_equal(list(G.edges(data=True)),
list(Gin.edges(data=True)))
assert_graphs_equal(G, Gin)
os.close(fd)
os.unlink(fname)
def test_default_attribute(self):
G = nx.Graph(name="Fred")
G.add_node(1, label=1, color="green")
nx.add_path(G, [0, 1, 2, 3])
G.add_edge(1, 2, weight=3)
G.graph["node_default"] = {"color": "yellow"}
G.graph["edge_default"] = {"weight": 7}
fh = io.BytesIO()
self.writer(G, fh)
fh.seek(0)
H = nx.read_graphml(fh, node_type=int)
assert_nodes_equal(G.nodes(), H.nodes())
assert_edges_equal(G.edges(), H.edges())
assert G.graph == H.graph
def test_weighted_path(self):
G = nx.path_graph(6)
for i in range(5):
G[i][i + 1]["weight"] = i + 1
partition = [{0, 1}, {2, 3}, {4, 5}]
M = nx.quotient_graph(G, partition, relabel=True)
assert_nodes_equal(M, [0, 1, 2])
assert_edges_equal(M.edges(), [(0, 1), (1, 2)])
assert M[0][1]["weight"] == 2
assert M[1][2]["weight"] == 4
for n in M:
assert M.nodes[n]["nedges"] == 1
assert M.nodes[n]["nnodes"] == 2
assert M.nodes[n]["density"] == 1
def test_default_attribute(self):
G = nx.Graph(name="Fred")
G.add_node(1, label=1, color='green')
nx.add_path(G, [0, 1, 2, 3])
G.add_edge(1, 2, weight=3)
G.graph['node_default'] = {'color': 'yellow'}
G.graph['edge_default'] = {'weight': 7}
fh = io.BytesIO()
self.writer(G, fh)
fh.seek(0)
H = nx.read_graphml(fh, node_type=int)
assert_nodes_equal(G.nodes(), H.nodes())
assert_edges_equal(G.edges(), H.edges())
assert G.graph == H.graph
def test_selfloops(self):
G = self.K3.copy()
G.add_edge(0, 0)
assert_nodes_equal(nx.nodes_with_selfloops(G), [0])
assert_edges_equal(nx.selfloop_edges(G), [(0, 0)])
assert nx.number_of_selfloops(G) == 1
G.remove_edge(0, 0)
G.add_edge(0, 0)
G.remove_edges_from([(0, 0)])
G.add_edge(1, 1)
G.remove_node(1)
G.add_edge(0, 0)
G.add_edge(1, 1)
G.remove_nodes_from([0, 1])
def test_selfloops():
graphs = [nx.Graph(), nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()]
for graph in graphs:
G = nx.complete_graph(3, create_using=graph)
G.add_edge(0, 0)
assert_nodes_equal(nx.nodes_with_selfloops(G), [0])
assert_edges_equal(nx.selfloop_edges(G), [(0, 0)])
assert_edges_equal(nx.selfloop_edges(G, data=True), [(0, 0, {})])
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)])
def test_read_attribute_graphml(self):
G = self.attribute_graph
H = nx.read_graphml(self.attribute_fh)
assert_nodes_equal(G.nodes(True), sorted(H.nodes(data=True)))
ge = sorted(G.edges(data=True))
he = sorted(H.edges(data=True))
for a, b in zip(ge, he):
assert a == b
self.attribute_fh.seek(0)
I = nx.parse_graphml(self.attribute_data)
assert sorted(G.nodes(True)) == sorted(I.nodes(data=True))
ge = sorted(G.edges(data=True))
he = sorted(I.edges(data=True))
for a, b in zip(ge, he):
assert a == b
def test_from_graph6_bytes(self):
data = b'DF{'
G=nx.from_graph6_bytes(data)
assert_nodes_equal(G.nodes(),[0, 1, 2, 3, 4])
assert_edges_equal(G.edges(),
[(0, 3), (0, 4), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)])
