def test_graph(self):
g = nx.cycle_graph(10)
G = nx.Graph()
G.add_nodes_from(g)
G.add_weighted_edges_from((u, v, u) for u, v in g.edges())
# Dict of dicts
dod = to_dict_of_dicts(G)
GG = from_dict_of_dicts(dod, create_using=nx.Graph)
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod, create_using=nx.Graph)
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.Graph(dod)
assert sorted(G.nodes()) == sorted(GI.nodes())
assert sorted(G.edges()) == sorted(GI.edges())
# Dict of lists
dol = to_dict_of_lists(G)
GG = from_dict_of_lists(dol, create_using=nx.Graph)
# dict of lists throws away edge data so set it to none
enone = [(u, v, {}) for (u, v, d) in G.edges(data=True)]
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(enone, sorted(GG.edges(data=True)))
GW = to_networkx_graph(dol, create_using=nx.Graph)
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(enone, sorted(GW.edges(data=True)))
GI = nx.Graph(dol)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(enone, sorted(GI.edges(data=True)))
def test_graph(self):
g = nx.cycle_graph(10)
G = nx.Graph()
G.add_nodes_from(g)
G.add_weighted_edges_from((u, v, u) for u, v in g.edges())
# Dict of dicts
dod = to_dict_of_dicts(G)
GG = from_dict_of_dicts(dod, create_using=nx.Graph())
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod, create_using=nx.Graph())
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.Graph(dod)
assert_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_equal(sorted(G.edges()), sorted(GI.edges()))
# Dict of lists
dol = to_dict_of_lists(G)
GG = from_dict_of_lists(dol, create_using=nx.Graph())
# dict of lists throws away edge data so set it to none
enone = [(u, v, {}) for (u, v, d) in G.edges(data=True)]
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(enone, sorted(GG.edges(data=True)))
GW = to_networkx_graph(dol, create_using=nx.Graph())
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(enone, sorted(GW.edges(data=True)))
GI = nx.Graph(dol)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(enone, sorted(GI.edges(data=True)))
def test_with_multiedges_self_loops(self):
G = cycle_graph(10)
XG = nx.Graph()
XG.add_nodes_from(G)
XG.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM = nx.MultiGraph()
XGM.add_nodes_from(G)
XGM.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM.add_edge(0, 1, weight=2) # multiedge
XGS = nx.Graph()
XGS.add_nodes_from(G)
XGS.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGS.add_edge(0, 0, weight=100) # self loop
# Dict of dicts
# with self loops, OK
dod = to_dict_of_dicts(XGS)
GG = from_dict_of_dicts(dod, create_using=nx.Graph)
assert_nodes_equal(XGS.nodes(), GG.nodes())
assert_edges_equal(XGS.edges(), GG.edges())
GW = to_networkx_graph(dod, create_using=nx.Graph)
assert_nodes_equal(XGS.nodes(), GW.nodes())
assert_edges_equal(XGS.edges(), GW.edges())
GI = nx.Graph(dod)
assert_nodes_equal(XGS.nodes(), GI.nodes())
assert_edges_equal(XGS.edges(), GI.edges())
# Dict of lists
# with self loops, OK
dol = to_dict_of_lists(XGS)
GG = from_dict_of_lists(dol, create_using=nx.Graph)
# dict of lists throws away edge data so set it to none
enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)]
assert_nodes_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
assert_edges_equal(enone, sorted(GG.edges(data=True)))
GW = to_networkx_graph(dol, create_using=nx.Graph)
assert_nodes_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
assert_edges_equal(enone, sorted(GW.edges(data=True)))
GI = nx.Graph(dol)
assert_nodes_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
assert_edges_equal(enone, sorted(GI.edges(data=True)))
# Dict of dicts
# with multiedges, OK
dod = to_dict_of_dicts(XGM)
GG = from_dict_of_dicts(dod,
create_using=nx.MultiGraph,
multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod,
create_using=nx.MultiGraph,
multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(
dod) # convert can't tell whether to duplicate edges!
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
# assert_not_equal(sorted(XGM.edges()), sorted(GI.edges()))
assert not sorted(XGM.edges()) == sorted(GI.edges())
GE = from_dict_of_dicts(dod,
create_using=nx.MultiGraph,
multigraph_input=False)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GE.nodes()))
assert sorted(XGM.edges()) != sorted(GE.edges())
GI = nx.MultiGraph(XGM)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GI.edges()))
GM = nx.MultiGraph(G)
assert_nodes_equal(sorted(GM.nodes()), sorted(G.nodes()))
assert_edges_equal(sorted(GM.edges()), sorted(G.edges()))
# Dict of lists
# with multiedges, OK, but better write as DiGraph else you'll
# get double edges
dol = to_dict_of_lists(G)
GG = from_dict_of_lists(dol, create_using=nx.MultiGraph)
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dol, create_using=nx.MultiGraph)
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(dol)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GI.edges()))
def test_with_multiedges_self_loops(self):
G = cycle_graph(10)
XG = nx.Graph()
XG.add_nodes_from(G)
XG.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM = nx.MultiGraph()
XGM.add_nodes_from(G)
XGM.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGM.add_edge(0, 1, weight=2) # multiedge
XGS = nx.Graph()
XGS.add_nodes_from(G)
XGS.add_weighted_edges_from((u, v, u) for u, v in G.edges())
XGS.add_edge(0, 0, weight=100) # self loop
# Dict of dicts
# with self loops, OK
dod = to_dict_of_dicts(XGS)
GG = from_dict_of_dicts(dod, create_using=nx.Graph())
assert_nodes_equal(XGS.nodes(), GG.nodes())
assert_edges_equal(XGS.edges(), GG.edges())
GW = to_networkx_graph(dod, create_using=nx.Graph())
assert_nodes_equal(XGS.nodes(), GW.nodes())
assert_edges_equal(XGS.edges(), GW.edges())
GI = nx.Graph(dod)
assert_nodes_equal(XGS.nodes(), GI.nodes())
assert_edges_equal(XGS.edges(), GI.edges())
# Dict of lists
# with self loops, OK
dol = to_dict_of_lists(XGS)
GG = from_dict_of_lists(dol, create_using=nx.Graph())
# dict of lists throws away edge data so set it to none
enone = [(u, v, {}) for (u, v, d) in XGS.edges(data=True)]
assert_nodes_equal(sorted(XGS.nodes()), sorted(GG.nodes()))
assert_edges_equal(enone, sorted(GG.edges(data=True)))
GW = to_networkx_graph(dol, create_using=nx.Graph())
assert_nodes_equal(sorted(XGS.nodes()), sorted(GW.nodes()))
assert_edges_equal(enone, sorted(GW.edges(data=True)))
GI = nx.Graph(dol)
assert_nodes_equal(sorted(XGS.nodes()), sorted(GI.nodes()))
assert_edges_equal(enone, sorted(GI.edges(data=True)))
# Dict of dicts
# with multiedges, OK
dod = to_dict_of_dicts(XGM)
GG = from_dict_of_dicts(dod, create_using=nx.MultiGraph(),
multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dod, create_using=nx.MultiGraph(), multigraph_input=True)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(dod) # convert can't tell whether to duplicate edges!
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
#assert_not_equal(sorted(XGM.edges()), sorted(GI.edges()))
assert_false(sorted(XGM.edges()) == sorted(GI.edges()))
GE = from_dict_of_dicts(dod, create_using=nx.MultiGraph(),
multigraph_input=False)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GE.nodes()))
assert_not_equal(sorted(XGM.edges()), sorted(GE.edges()))
GI = nx.MultiGraph(XGM)
assert_nodes_equal(sorted(XGM.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(XGM.edges()), sorted(GI.edges()))
GM = nx.MultiGraph(G)
assert_nodes_equal(sorted(GM.nodes()), sorted(G.nodes()))
assert_edges_equal(sorted(GM.edges()), sorted(G.edges()))
# Dict of lists
# with multiedges, OK, but better write as DiGraph else you'll
# get double edges
dol = to_dict_of_lists(G)
GG = from_dict_of_lists(dol, create_using=nx.MultiGraph())
assert_nodes_equal(sorted(G.nodes()), sorted(GG.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GG.edges()))
GW = to_networkx_graph(dol, create_using=nx.MultiGraph())
assert_nodes_equal(sorted(G.nodes()), sorted(GW.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GW.edges()))
GI = nx.MultiGraph(dol)
assert_nodes_equal(sorted(G.nodes()), sorted(GI.nodes()))
assert_edges_equal(sorted(G.edges()), sorted(GI.edges()))
import networkx as nx
import matplotlib.pyplot as plt
from networkx.convert import to_dict_of_lists, to_edgelist
from networkx.convert_matrix import to_numpy_array
"""
https://networkx.org/documentation/stable/reference/convert.html
"""
n_nodes = 20
n_edges = 40
G = nx.generators.random_graphs.gnm_random_graph(n_nodes, n_edges)
print("G nodes")
print(G.nodes)
for node in G.nodes:
print(node)
print("\nG edges")
print(G.edges)
print("\nG as dictionary of lists")
print(to_dict_of_lists(G))
print("\nG as a numpy array")
print(to_numpy_array(G))
