def check_clabel(cx):
"""
params: cx generator
Check all clabel >= -1.
Check numer of clabels == number of nodes
"""
node_clabels = defaultdict(int)
edge_clabels = defaultdict(int)
node_num = 0
edge_num = 0
for aspect in cx:
which = aspect.WhichOneof('element')
if which == 'node':
node_num += 1
elif which == 'nodeAttribute':
attr = aspect.nodeAttribute
if not attr.name.startswith("clabel"):
continue
value = GraphToolAdapter.parse_value(attr)
assert value >= -1, "node clabel value is less than -1 value: %s" % (value)
node_clabels[attr.name] += 1
elif which == 'edge':
edge_num += 1
elif which == 'edgeAttribute':
attr = aspect.edgeAttribute
if not attr.name.startswith("clabel"):
continue
value = GraphToolAdapter.parse_value(attr)
assert value >= -1, "edge clabel value is less than -1 value: %s" % (value)
edge_clabels[attr.name] += 1
for clabel_name, clabel_count in node_clabels.items():
assert clabel_count == node_num, "number of node clabels does not equal to number of nodes. clabel: %s, node: %s" % (clabel_count, node_num)
for clabel_name, clabel_count in edge_clabels.items():
assert clabel_count == edge_num, "number of edge clabels does not equal to number of edges. clabel: %s, node: %s" % (clabel_count, edge_num)
def create_mock_graph_tool(label='network_label', num_nodes=100, num_edges=100, data={}):
edgeList = {}
n = graph_tool.Graph()
n.gp.label = n.new_gp("string")
n.gp.label = label
n.vp.name = n.new_vp("string")
n.ep.id = n.new_ep("int")
for n_id in range(num_nodes):
v = n.add_vertex()
n.vp.name[v] = hex(n_id)
ID = num_nodes
for e_id in range(num_edges):
n1 = random.randint(0, num_nodes-1)
n2 = random.randint(0, num_nodes-2)
val = random.choice([1, 1.5, 'a', True])
edgeList[ID] = (n1, n2)
e = n.add_edge(n.vertex(n1), n.vertex(n2))
n.ep.id[e] = ID
n.ep.value = n.new_ep(GraphToolAdapter.get_gt_type(val)) # TODO: avoid destructive assiginment
n.ep.value[e] = val
ID += 1
for k, v in data.items():
if k not in n.gp:
n.gp[k] = n.new_gp(GraphToolAdapter.get_gt_type(v))
n.gp[k] = v
return n, edgeList
def process(self, params, input_stream):
logging.debug(params)
# Convert to graph-tool objects
gs = GraphToolAdapter.to_graph_tool(input_stream)
ts, tposs = self.process_graphs(params, gs)
return GraphToolAdapter.from_graph_tool(ts, tposs, False)
def testMultipleNetworks(self):
nets = [
create_mock_graph_tool('net1')[0],
create_mock_graph_tool('net2')[0]
]
streams = GraphToolAdapter.from_graph_tool(nets)
res_nets = GraphToolAdapter.to_graph_tool(streams)
compare_graph_tool(nets[0], res_nets[0])
compare_graph_tool(nets[1], res_nets[1])
def testUnusualAttributeType(self):
net, edgeList = create_mock_graph_tool(num_nodes=100,
num_edges=50,
data={'keyDict': {
1: 2
}})
stream = GraphToolAdapter.from_graph_tool([net])
net_res_list = GraphToolAdapter.to_graph_tool(stream)
compare_graph_tool(net, net_res_list[0])
# autoconvert to string for unrecognized value types
self.assertEqual(str(net.gp['keyDict']), net_res_list[0].gp['keyDict'])
def test_get_gt_type(self):
self.assertEqual(GraphToolAdapter.get_gt_type(1), 'int')
self.assertEqual(GraphToolAdapter.get_gt_type(1.0), 'float')
self.assertEqual(GraphToolAdapter.get_gt_type(True), 'bool')
self.assertEqual(GraphToolAdapter.get_gt_type("asdf"), 'string')
self.assertEqual(GraphToolAdapter.get_gt_type({1: "asdf"}), 'object')
self.assertEqual(GraphToolAdapter.get_gt_type([1]), 'vector<int>')
self.assertEqual(GraphToolAdapter.get_gt_type([1.0]), 'vector<float>')
self.assertEqual(GraphToolAdapter.get_gt_type([True]), 'vector<bool>')
self.assertEqual(GraphToolAdapter.get_gt_type(["asdf"]),
'vector<string>')
self.assertEqual(GraphToolAdapter.get_gt_type([{1: "asdf"}]), 'object')
def test_with_parameter(self):
net1, edgeList = create_mock_graph_tool(num_nodes=100, num_edges=300)
GLS = GtLayoutService()
params = {
'layout-name': 'default',
'only-layout': True,
'root': 0,
'vweight': 'vweight',
'eweight': 'eweight',
'pin': 'pin',
'groups': 'groups',
'pos': 'pos',
'weight': 'weight',
'rel_order': 'rel_order',
'node_weight': 'node_weight'
}
params["vweight"] = "vw"
params["eweight"] = "ew"
net1.vp.vw = net1.new_vp("int")
net1.ep.ew = net1.new_ep("int")
for v in net1.vertices():
net1.vp.vw[v] = random.randint(0, 100)
for edge in net1.edges():
net1.ep.ew[edge] = random.randint(0, 100)
gs, poss = GLS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
b, dp = has_unique_position(cx)
assert b, "There are same position nodes. %s" % (dp)
b, ns, ls = has_corresponding_layout(cx)
assert b, "Set of Node id and Set of Layout are different. <node %s> != <layout %s>" % (
ns, ls)
def test_all_algorithms(self):
net1, edgeList = create_mock_planar(dim=[10, 15])
GLS = GtLayoutService()
params = {
'layout-name': 'default',
'only-layout': True,
'root': 10,
'vweight': 'vweight',
'eweight': 'eweight',
'pin': 'pin',
'groups': 'groups',
'pos': 'pos',
'weight': 'weight',
'rel_order': 'rel_order',
'node_weight': 'node_weight'
}
layout_names = [
"sfdp_layout", "fruchterman_reingold_layout", "arf_layout",
"radial_tree_layout", "planar_layout", "random_layout"
]
# layout_names = ["sfdp_layout", "fruchterman_reingold_layout", "arf_layout", "radial_tree_layout", "random_layout"]
for l in layout_names:
params['layout-name'] = l
gs, poss = GLS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
b, ns, ls = has_corresponding_layout(cx)
assert b, "Set of Node id and Set of Layout are different. Algorithm: %s <node %s> != <layout %s>" % (
l, ns, ls)
def test_to_graph_tool(self):
net, edgeList = create_mock_graph_tool(num_nodes=100,
num_edges=50,
data={
'keyStr': 'value',
'keyInt': 1,
'keyFloat': 1.2,
'keyBool': True
})
stream = GraphToolAdapter.from_graph_tool([net])
net_res_list = GraphToolAdapter.to_graph_tool(stream)
compare_graph_tool(net, net_res_list[0])
self.assertEqual(net.gp.keys(), net_res_list[0].gp.keys())
for k in net.gp.keys():
self.assertEqual(net.gp[k], net_res_list[0].gp[k])
def test_clabel(self):
net1, edgeList = create_mock_graph_tool(num_nodes=30, num_edges=100)
GDHS = GtDrawHierarchyService()
params = {'layout': 'radial', 'pos': 'pos', 'beta': 8, 'deg_order': True, 'deg_size': True, 'vsize_scale': 1.0, 'hsize_scale': 1.0, 'hshortcuts': 0, 'hide': 0, 'bip_aspect': 1.0, 'empty_branches': False, 'only-layout': True}
gs, poss = GDHS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
check_clabel(cx)
def test_nodes_have_unique_position(self):
net1, edgeList = create_mock_graph_tool(num_nodes=30, num_edges=100)
GDHS = GtDrawHierarchyService()
params = {'layout': 'radial', 'pos': 'pos', 'beta': 8, 'deg_order': True, 'deg_size': True, 'vsize_scale': 1.0, 'hsize_scale': 1.0, 'hshortcuts': 0, 'hide': 0, 'bip_aspect': 1.0, 'empty_branches': False, 'only-layout': True}
gs, poss = GDHS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
b, dp = has_unique_position(cx)
assert b, "There are same position nodes. %s" % (dp)
def test_all_nodes_have_layout(self):
net1, edgeList = create_mock_graph_tool(num_nodes=30, num_edges=100)
GDHS = GtDrawHierarchyService()
params = {'layout': 'radial', 'pos': 'pos', 'beta': 8, 'deg_order': True, 'deg_size': True, 'vsize_scale': 1.0, 'hsize_scale': 1.0, 'hshortcuts': 0, 'hide': 0, 'bip_aspect': 1.0, 'empty_branches': False, 'only-layout': True}
gs, poss = GDHS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
b, ns, ls = has_corresponding_layout(cx)
assert b, "Set of Node id and Set of Layout are different. <node %s> != <layout %s>" % (ns, ls)
def test_all_algorithms(self):
net1, edgeList = create_mock_planar(dim=[5, 5])
GDHS = GtDrawHierarchyService()
params = {'layout': 'radial', 'pos': 'pos', 'beta': 8, 'deg_order': True, 'deg_size': True, 'vsize_scale': 1.0, 'hsize_scale': 1.0, 'hshortcuts': 0, 'hide': 0, 'bip_aspect': 1.0, 'empty_branches': False, 'only-layout': True}
layout_names = ["sfdp", "radial", "bipartite"]
for l in layout_names:
params['layout'] = l
gs, poss = GDHS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
b, ns, ls = has_corresponding_layout(cx)
assert b, "Set of Node id and Set of Layout are different. Algorithm: %s <node %s> != <layout %s>" % (l, ns, ls)
def create_mock_planar(label='network_label', dim=[10 ,10], data={}):
edgeList = {}
n = graph_tool.generation.lattice(dim)
n.gp.label = n.new_gp("string")
n.gp.label = label
n.vp.name = n.new_vp("string")
n.ep.id = n.new_ep("int")
ID = 0
for v in n.vertices():
n.vp.name[v] = hex(ID)
ID += 1
for edge in n.edges():
source_node, target_node = edge.source(), edge.target()
edgeList[ID] = (int(source_node), int(target_node))
ID += 1
for k, v in data.items():
if k not in n.gp:
n.gp[k] = n.new_gp(GraphToolAdapter.get_gt_type(v))
n.gp[k] = v
return n, edgeList
def test_nodes_have_unique_position(self):
net1, edgeList = create_mock_graph_tool(num_nodes=100, num_edges=300)
GLS = GtLayoutService()
params = {
'layout-name': 'default',
'only-layout': True,
'root': 0,
'vweight': 'vweight',
'eweight': 'eweight',
'pin': 'pin',
'groups': 'groups',
'pos': 'pos',
'weight': 'weight',
'rel_order': 'rel_order',
'node_weight': 'node_weight'
}
gs, poss = GLS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
b, dp = has_unique_position(cx)
assert b, "There are same position nodes. %s" % (dp)
def test_large_graph(self):
net1, edgeList = create_mock_graph_tool(num_nodes=1000, num_edges=3000)
GLS = GtLayoutService()
params = {
'layout-name': 'default',
'only-layout': True,
'root': 0,
'vweight': 'vweight',
'eweight': 'eweight',
'pin': 'pin',
'groups': 'groups',
'pos': 'pos',
'weight': 'weight',
'rel_order': 'rel_order',
'node_weight': 'node_weight'
}
gs, poss = GLS.process_graphs(params, [net1])
cx = GraphToolAdapter.from_graph_tool(gs, poss)
b, ns, ls = has_corresponding_layout(cx)
assert b, "Set of Node id and Set of Layout are different. <node %s> != <layout %s>" % (
ns, ls)
def test_from_graph_tool(self):
net, edgeList = create_mock_graph_tool(num_nodes=100, num_edges=50)
net.gp.desc = net.new_gp("string")
net.gp.desc = 'example'
nodeCount = 0
edgeCount = 0
for aspect in GraphToolAdapter.from_graph_tool([net]):
which = aspect.WhichOneof('element')
if which == 'node':
nodeCount += 1
node = aspect.node
self.assertEqual(net.vp['name'][net.vertex(node.id)],
node.name)
elif which == 'edge':
edgeCount += 1
edge = aspect.edge
self.assertEqual(
edge.id, net.ep.id[net.edge(edge.sourceId, edge.targetId)])
elif which == 'nodeAttribute':
attr = aspect.nodeAttribute
self.assertEqual(net.vp[attr.name][net.vertex(node.id)],
attr.value)
elif which == 'edgeAttribute':
attr = aspect.edgeAttribute
a, b = edgeList[attr.edgeId]
self.assertEqual(
str(net.ep.value[net.edge(edge.sourceId, edge.targetId)]),
attr.value)
elif which == 'networkAttribute':
attr = aspect.networkAttribute
self.assertEqual(net.gp[attr.name], attr.value)
else:
print("UNTESTED %s" % aspect)
self.assertEqual(nodeCount, len(net.get_vertices()))
self.assertEqual(edgeCount, len(net.get_edges()))
def testLargeNetwork(self):
net, edgeList = create_mock_graph_tool(num_nodes=10000, num_edges=5000)
stream = GraphToolAdapter.from_graph_tool([net])
net_res_list = GraphToolAdapter.to_graph_tool(stream)
compare_graph_tool(net, net_res_list[0])
def process(self, params, input_stream):
logging.debug(params)
ol = params.pop("only-layout")
gs = GraphToolAdapter.to_graph_tool(input_stream)
gs, poss = self.process_graphs(params, gs)
return GraphToolAdapter.from_graph_tool(gs, poss, ol)
