def test_simple_graphs(self):
for dest, source in [
(to_dict_of_dicts, from_dict_of_dicts),
(to_dict_of_lists, from_dict_of_lists),
]:
G = barbell_graph(10, 3)
G.graph = {}
dod = dest(G)
# Dict of [dicts, lists]
GG = source(dod)
assert graphs_equal(G, GG)
GW = to_networkx_graph(dod)
assert graphs_equal(G, GW)
GI = nx.Graph(dod)
assert graphs_equal(G, GI)
# With nodelist keyword
P4 = nx.path_graph(4)
P3 = nx.path_graph(3)
P4.graph = {}
P3.graph = {}
dod = dest(P4, nodelist=[0, 1, 2])
Gdod = nx.Graph(dod)
assert graphs_equal(Gdod, P3)
def test_roundtrip(self, graph):
# edgelist
Gtrue = graph([(1, 1), (1, 2)])
df = nx.to_pandas_edgelist(Gtrue)
G = nx.from_pandas_edgelist(df, create_using=graph)
assert graphs_equal(Gtrue, G)
# adjacency
adj = {1: {1: {"weight": 1}, 2: {"weight": 1}}, 2: {1: {"weight": 1}}}
Gtrue = graph(adj)
df = nx.to_pandas_adjacency(Gtrue, dtype=int)
G = nx.from_pandas_adjacency(df, create_using=graph)
assert graphs_equal(Gtrue, G)
def test_round_trip_empty_graph(self):
G = nx.Graph()
A = nx.nx_agraph.to_agraph(G)
H = nx.nx_agraph.from_agraph(A)
# assert graphs_equal(G, H)
AA = nx.nx_agraph.to_agraph(H)
HH = nx.nx_agraph.from_agraph(AA)
assert graphs_equal(H, HH)
G.graph["graph"] = {}
G.graph["node"] = {}
G.graph["edge"] = {}
assert graphs_equal(G, HH)
def test_from_scipy_sparse_matrix_formats(sparse_format):
"""Test all formats supported by _generate_weighted_edges."""
# trinode complete graph with non-uniform edge weights
expected = nx.Graph()
expected.add_edges_from([
(0, 1, {
"weight": 3
}),
(0, 2, {
"weight": 2
}),
(1, 0, {
"weight": 3
}),
(1, 2, {
"weight": 1
}),
(2, 0, {
"weight": 2
}),
(2, 1, {
"weight": 1
}),
])
A = sp.sparse.coo_matrix([[0, 3, 2], [3, 0, 1],
[2, 1, 0]]).asformat(sparse_format)
assert graphs_equal(expected, nx.from_scipy_sparse_matrix(A))
def test_read_write(self):
G = nx.MultiGraph()
G.graph["name"] = "G"
G.add_edge("1", "2", key="0") # read assumes strings
fh = StringIO()
nx.nx_pydot.write_dot(G, fh)
fh.seek(0)
H = nx.nx_pydot.read_dot(fh)
assert graphs_equal(G, H)
def assert_graphs_equal(graph1, graph2):
warnings.warn(
(
"`assert_graphs_equal` is deprecated and will be removed in version 3.0.\n"
"Use `from networkx.utils import graphs_equal` and `assert graphs_equal` instead.\n"
),
DeprecationWarning,
)
assert graphs_equal(graph1, graph2)
def test_symmetric(self):
"""Tests that a symmetric array has edges added only once to an
undirected multigraph when using :func:`networkx.from_numpy_array`.
"""
A = np.array([[0, 1], [1, 0]])
G = nx.from_numpy_array(A, create_using=nx.MultiGraph)
expected = nx.MultiGraph()
expected.add_edge(0, 1, weight=1)
assert graphs_equal(G, expected)
def test_unicode(self):
G = nx.Graph()
name1 = chr(2344) + chr(123) + chr(6543)
name2 = chr(5543) + chr(1543) + chr(324)
G.add_edge(name1, "Radiohead", **{name2: 3})
fd, fname = tempfile.mkstemp()
nx.write_edgelist(G, fname)
H = nx.read_edgelist(fname)
assert graphs_equal(G, H)
os.close(fd)
os.unlink(fname)
def test_latin1(self):
G = nx.Graph()
name1 = "Bj" + chr(246) + "rk"
name2 = chr(220) + "ber"
G.add_edge(name1, "Radiohead", **{name2: 3})
fd, fname = tempfile.mkstemp()
nx.write_edgelist(G, fname, encoding="latin-1")
H = nx.read_edgelist(fname, encoding="latin-1")
assert graphs_equal(G, H)
os.close(fd)
os.unlink(fname)
def test_symmetric(self):
"""Tests that a symmetric matrix has edges added only once to an
undirected multigraph when using
:func:`networkx.from_scipy_sparse_matrix`.
"""
A = sp.sparse.csr_matrix([[0, 1], [1, 0]])
G = nx.from_scipy_sparse_matrix(A, create_using=nx.MultiGraph)
expected = nx.MultiGraph()
expected.add_edge(0, 1, weight=1)
assert graphs_equal(G, expected)
def test_from_edgelist_int_attr_name(self):
# note: this also tests that edge_attr can be `source`
Gtrue = nx.Graph([("E", "C", {
0: "C"
}), ("B", "A", {
0: "B"
}), ("A", "D", {
0: "A"
})])
G = nx.from_pandas_edgelist(self.df, 0, "b", 0)
assert graphs_equal(G, Gtrue)
def test_read_multiline_adjlist_1(self):
# Unit test for https://networkx.lanl.gov/trac/ticket/252
s = b"""# comment line
1 2
# comment line
2
3
"""
bytesIO = io.BytesIO(s)
G = nx.read_multiline_adjlist(bytesIO)
adj = {"1": {"3": {}, "2": {}}, "3": {"1": {}}, "2": {"1": {}}}
assert graphs_equal(G, nx.Graph(adj))
def test_from_scipy_sparse_matrix_parallel_edges(self):
"""Tests that the :func:`networkx.from_scipy_sparse_matrix` function
interprets integer weights as the number of parallel edges when
creating a multigraph.
"""
A = sp.sparse.csr_matrix([[1, 1], [1, 2]])
# First, with a simple graph, each integer entry in the adjacency
# matrix is interpreted as the weight of a single edge in the graph.
expected = nx.DiGraph()
edges = [(0, 0), (0, 1), (1, 0)]
expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
expected.add_edge(1, 1, weight=2)
actual = nx.from_scipy_sparse_matrix(A,
parallel_edges=True,
create_using=nx.DiGraph)
assert graphs_equal(actual, expected)
actual = nx.from_scipy_sparse_matrix(A,
parallel_edges=False,
create_using=nx.DiGraph)
assert graphs_equal(actual, expected)
# Now each integer entry in the adjacency matrix is interpreted as the
# number of parallel edges in the graph if the appropriate keyword
# argument is specified.
edges = [(0, 0), (0, 1), (1, 0), (1, 1), (1, 1)]
expected = nx.MultiDiGraph()
expected.add_weighted_edges_from([(u, v, 1) for (u, v) in edges])
actual = nx.from_scipy_sparse_matrix(A,
parallel_edges=True,
create_using=nx.MultiDiGraph)
assert graphs_equal(actual, expected)
expected = nx.MultiDiGraph()
expected.add_edges_from(set(edges), weight=1)
# The sole self-loop (edge 0) on vertex 1 should have weight 2.
expected[1][1][0]["weight"] = 2
actual = nx.from_scipy_sparse_matrix(A,
parallel_edges=False,
create_using=nx.MultiDiGraph)
assert graphs_equal(actual, expected)
def test_from_edgelist_all_attr(self):
Gtrue = nx.Graph([
("E", "C", {
"cost": 9,
"weight": 10
}),
("B", "A", {
"cost": 1,
"weight": 7
}),
("A", "D", {
"cost": 7,
"weight": 4
}),
])
G = nx.from_pandas_edgelist(self.df, 0, "b", True)
assert graphs_equal(G, Gtrue)
# MultiGraph
MGtrue = nx.MultiGraph(Gtrue)
MGtrue.add_edge("A", "D", cost=16, weight=4)
MG = nx.from_pandas_edgelist(self.mdf, 0, "b", True, nx.MultiGraph())
assert graphs_equal(MG, MGtrue)
def test_from_edgelist_one_attr(self):
Gtrue = nx.Graph([
("E", "C", {
"weight": 10
}),
("B", "A", {
"weight": 7
}),
("A", "D", {
"weight": 4
}),
])
G = nx.from_pandas_edgelist(self.df, 0, "b", "weight")
assert graphs_equal(G, Gtrue)
def test_edgekey_with_normal_graph_no_action(self):
Gtrue = nx.Graph([
("E", "C", {
"cost": 9,
"weight": 10
}),
("B", "A", {
"cost": 1,
"weight": 7
}),
("A", "D", {
"cost": 7,
"weight": 4
}),
])
G = nx.from_pandas_edgelist(self.df, 0, "b", True, edge_key="weight")
assert graphs_equal(G, Gtrue)
def test_from_edgelist_multi_attr_incl_target(self):
Gtrue = nx.Graph([
("E", "C", {
"b": "E",
"weight": 10
}),
("B", "A", {
"b": "A",
"weight": 7
}),
("A", "D", {
"b": "D",
"weight": 4
}),
])
G = nx.from_pandas_edgelist(self.df, 0, "b", ["b", "weight"])
assert graphs_equal(G, Gtrue)
def test_from_edgelist_multi_attr(self):
Gtrue = nx.Graph([
("E", "C", {
"cost": 9,
"weight": 10
}),
("B", "A", {
"cost": 1,
"weight": 7
}),
("A", "D", {
"cost": 7,
"weight": 4
}),
])
G = nx.from_pandas_edgelist(self.df, 0, "b", ["weight", "cost"])
assert graphs_equal(G, Gtrue)
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_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 pydot_checks(self, G, prog):
"""
Validate :mod:`pydot`-based usage of the passed NetworkX graph with the
passed basename of an external GraphViz command (e.g., `dot`, `neato`).
"""
# Set the name of this graph to... "G". Failing to do so will
# subsequently trip an assertion expecting this name.
G.graph["name"] = "G"
# Add arbitrary nodes and edges to the passed empty graph.
G.add_edges_from([("A", "B"), ("A", "C"), ("B", "C"), ("A", "D")])
G.add_node("E")
# Validate layout of this graph with the passed GraphViz command.
graph_layout = nx.nx_pydot.pydot_layout(G, prog=prog)
assert isinstance(graph_layout, dict)
# Convert this graph into a "pydot.Dot" instance.
P = nx.nx_pydot.to_pydot(G)
# Convert this "pydot.Dot" instance back into a graph of the same type.
G2 = G.__class__(nx.nx_pydot.from_pydot(P))
# Validate the original and resulting graphs to be the same.
assert graphs_equal(G, G2)
fd, fname = tempfile.mkstemp()
# Serialize this "pydot.Dot" instance to a temporary file in dot format
P.write_raw(fname)
# Deserialize a list of new "pydot.Dot" instances back from this file.
Pin_list = pydot.graph_from_dot_file(path=fname, encoding="utf-8")
# Validate this file to contain only one graph.
assert len(Pin_list) == 1
# The single "pydot.Dot" instance deserialized from this file.
Pin = Pin_list[0]
# Sorted list of all nodes in the original "pydot.Dot" instance.
n1 = sorted([p.get_name() for p in P.get_node_list()])
# Sorted list of all nodes in the deserialized "pydot.Dot" instance.
n2 = sorted([p.get_name() for p in Pin.get_node_list()])
# Validate these instances to contain the same nodes.
assert n1 == n2
# Sorted list of all edges in the original "pydot.Dot" instance.
e1 = sorted([(e.get_source(), e.get_destination())
for e in P.get_edge_list()])
# Sorted list of all edges in the original "pydot.Dot" instance.
e2 = sorted([(e.get_source(), e.get_destination())
for e in Pin.get_edge_list()])
# Validate these instances to contain the same edges.
assert e1 == e2
# Deserialize a new graph of the same type back from this file.
Hin = nx.nx_pydot.read_dot(fname)
Hin = G.__class__(Hin)
# Validate the original and resulting graphs to be the same.
assert graphs_equal(G, Hin)
os.close(fd)
os.unlink(fname)
def test_update(self):
# specify both edges 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, {}),
]
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}),
]
else:
if os.environ.get("DEPLOYMENT", None) == "standalone":
elist = [
(0, 1, {}),
(0, 2, {}),
(1, 2, {}),
(4, 5, {}),
(6, 7, {"weight": 2}),
]
else: # num_workers = 2
elist = [
(0, 2, {}),
(1, 0, {}),
(1, 2, {}),
(5, 4, {}),
(7, 6, {"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})])
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.add_node(2, data=4)
G.add_edge(0, 1, weight=0.5)
GG = G.copy()
H = self.Graph()
GG.update(H)
assert graphs_equal(G, GG)
H.update(G)
assert graphs_equal(H, G)
# update nodes only
H = self.Graph()
H.update(nodes=[3, 4])
assert H.nodes ^ {3, 4} == set()
assert H.size() == 0
# update edges only
H = self.Graph()
H.update(edges=[(3, 4)])
if H.is_directed():
assert sorted(H.edges.data()) == [(3, 4, {})]
else:
assert sorted(H.edges.data()) in ([(3, 4, {})], [(4, 3, {})])
assert H.size() == 1
# No inputs -> exception
with pytest.raises(nx.NetworkXError):
nx.Graph().update()
def test_from_edgelist_no_attr(self):
Gtrue = nx.Graph([("E", "C", {}), ("B", "A", {}), ("A", "D", {})])
G = nx.from_pandas_edgelist(self.df, 0, "b")
assert graphs_equal(G, Gtrue)
def test_implementations_consistent(strings):
"""Ensure results are consistent between prefix_tree implementations."""
assert graphs_equal(nx.prefix_tree(strings),
nx.prefix_tree_recursive(strings))
def test_edgekey_with_multigraph(self):
df = pd.DataFrame({
"source": {
"A": "N1",
"B": "N2",
"C": "N1",
"D": "N1"
},
"target": {
"A": "N2",
"B": "N3",
"C": "N1",
"D": "N2"
},
"attr1": {
"A": "F1",
"B": "F2",
"C": "F3",
"D": "F4"
},
"attr2": {
"A": 1,
"B": 0,
"C": 0,
"D": 0
},
"attr3": {
"A": 0,
"B": 1,
"C": 0,
"D": 1
},
})
Gtrue = nx.MultiGraph([
("N1", "N2", "F1", {
"attr2": 1,
"attr3": 0
}),
("N2", "N3", "F2", {
"attr2": 0,
"attr3": 1
}),
("N1", "N1", "F3", {
"attr2": 0,
"attr3": 0
}),
("N1", "N2", "F4", {
"attr2": 0,
"attr3": 1
}),
])
# example from issue #4065
G = nx.from_pandas_edgelist(
df,
source="source",
target="target",
edge_attr=["attr2", "attr3"],
edge_key="attr1",
create_using=nx.MultiGraph(),
)
assert graphs_equal(G, Gtrue)
df_roundtrip = nx.to_pandas_edgelist(G, edge_key="attr1")
df_roundtrip = df_roundtrip.sort_values("attr1")
df_roundtrip.index = ["A", "B", "C", "D"]
pd.testing.assert_frame_equal(
df, df_roundtrip[["source", "target", "attr1", "attr2", "attr3"]])
def test_from_edgelist_multidigraph_and_edge_attr(self):
# example from issue #2374
edges = [
("X1", "X4", {
"Co": "zA",
"Mi": 0,
"St": "X1"
}),
("X1", "X4", {
"Co": "zB",
"Mi": 54,
"St": "X2"
}),
("X1", "X4", {
"Co": "zB",
"Mi": 49,
"St": "X3"
}),
("X1", "X4", {
"Co": "zB",
"Mi": 44,
"St": "X4"
}),
("Y1", "Y3", {
"Co": "zC",
"Mi": 0,
"St": "Y1"
}),
("Y1", "Y3", {
"Co": "zC",
"Mi": 34,
"St": "Y2"
}),
("Y1", "Y3", {
"Co": "zC",
"Mi": 29,
"St": "X2"
}),
("Y1", "Y3", {
"Co": "zC",
"Mi": 24,
"St": "Y3"
}),
("Z1", "Z3", {
"Co": "zD",
"Mi": 0,
"St": "Z1"
}),
("Z1", "Z3", {
"Co": "zD",
"Mi": 14,
"St": "X3"
}),
]
Gtrue = nx.MultiDiGraph(edges)
data = {
"O": ["X1", "X1", "X1", "X1", "Y1", "Y1", "Y1", "Y1", "Z1", "Z1"],
"D": ["X4", "X4", "X4", "X4", "Y3", "Y3", "Y3", "Y3", "Z3", "Z3"],
"St": ["X1", "X2", "X3", "X4", "Y1", "Y2", "X2", "Y3", "Z1", "X3"],
"Co": ["zA", "zB", "zB", "zB", "zC", "zC", "zC", "zC", "zD", "zD"],
"Mi": [0, 54, 49, 44, 0, 34, 29, 24, 0, 14],
}
df = pd.DataFrame.from_dict(data)
G1 = nx.from_pandas_edgelist(df,
source="O",
target="D",
edge_attr=True,
create_using=nx.MultiDiGraph)
G2 = nx.from_pandas_edgelist(
df,
source="O",
target="D",
edge_attr=["St", "Co", "Mi"],
create_using=nx.MultiDiGraph,
)
assert graphs_equal(G1, Gtrue)
assert graphs_equal(G2, Gtrue)
def test_round_trip_integer_nodes(self):
G = nx.complete_graph(3)
A = nx.nx_agraph.to_agraph(G)
H = nx.nx_agraph.from_agraph(A)
assert graphs_equal(G, H)
