def test_graph_condition_jump():
no_condition = graph.Edge()
assert(no_condition.can_jump())
assert(no_condition.can_jump('a'))
match_a = graph.Edge(lambda x: x == 'a')
assert(match_a.can_jump('a'))
assert( not match_a.can_jump('b'))
def build_graph(dfs_codes):
g = graph.Graph()
numnodes = max([x[0] for x in dfs_codes] + [x[1] for x in dfs_codes]) + 1
for i in range(numnodes):
n = graph.Node()
g.nodes.append(n)
for idx, c in enumerate(dfs_codes):
g.nodes[c.fromn].id = c.fromn
g.nodes[c.fromn].label = c.from_label
g.nodes[c.to].id = c.to
g.nodes[c.to].label = c.to_label
e = graph.Edge()
e.id = g.nedges
e.fromn = c.fromn
e.to = c.to
e.label = c.edge_label
g.nodes[c.fromn].edges.append(e)
e2 = graph.Edge()
e2.id = e.id
e2.label = e.label
e2.fromn = c.to
e2.to = c.fromn
g.nodes[c.to].edges.append(e2)
g.nedges += 1
return g
def unreverse_edges(g):
if g.root.label == 'multi-sentence':
roots = [edge.tails[0] for edge in g.root.outedges]
else:
roots = [g.root]
for node in g.dfs():
edges = []
for edge in node.outedges:
reverse = False
m = re.match(r"(.*)-of$", edge.label)
if m:
reverse = True
newlabel = m.group(1)
"""elif edge.label in ["purpose"] and not re.match(r".*-\d+^", node.label):
reverse = True
newlabel = edge.label + '-of'"""
if reverse:
(root, ) = edge.tails
root.outedges.append(graph.Edge(newlabel, [node]))
roots.append(root)
else:
edges.append(edge)
node.outedges = edges
dummy = graph.Graph(
graph.Node('dummy', [graph.Edge('dummy', [root]) for root in roots]))
components = dummy.scc()
cindex = {}
for ci, component in enumerate(components):
for node in component:
cindex[node] = ci
reachable = set()
for node in dummy.dfs():
if node is dummy:
reachable.add(cindex[node])
continue
for edge in node.outedges:
for tail in edge.tails:
if cindex[node] != cindex[tail]:
reachable.add(cindex[tail])
roots = [
component.pop() for ci, component in enumerate(components)
if ci not in reachable
]
if len(roots) > 1:
edges = []
for ri, root in enumerate(roots):
edges.append(graph.Edge('snt{0}'.format(ri + 1), [root]))
g.root = graph.Node('multi-sentence', edges)
else:
g.root = roots[0]
g.update()
def t2():
g = G.Graph.empty_graph()
e1 = G.Edge("n1", 100, "n2")
e2 = G.Edge("n3", 100, "n2")
e3 = G.Edge("n1", 200, "n3")
g.add_edge_list([e1, e2, e3])
simulation = Simulation(g, 1)
simulation.simulate(30)
def testIgnoresUnknownEdges(self):
nodes = [_IndexedNode(i) for i in xrange(7)]
edges = [graph.Edge(nodes[from_index], nodes[to_index])
for (from_index, to_index) in [
(0, 1), (0, 2), (1, 3), (3, 4), (5, 6)]]
edges.append(graph.Edge(nodes[4], _IndexedNode(42)))
edges.append(graph.Edge(_IndexedNode(42), nodes[5]))
g = graph.DirectedGraph(nodes, edges)
self.assertListEqual(range(7), sorted(self._NodesIndices(g)))
self.assertEqual(5, len(g.Edges()))
def test_find_length_shortest_route(self):
my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7']
my_graph = graph.Graph(my_edge_list)
AE7 = graph.Edge("A", "E", 7)
EB3 = graph.Edge("E", "B", 3)
AB5 = graph.Edge("A", "B", 5)
DE6 = graph.Edge("D", "E", 6)
BC4 = graph.Edge("B", "C", 4)
CD8 = graph.Edge("C", "D", 8)
DC8 = graph.Edge("D", "C", 8)
CE2 = graph.Edge("C", "E", 2)
AD5 = graph.Edge("A", "D", 5)
self.assertEqual(my_graph.find_length_shortest_route("A", "A"), "NO SUCH ROUTE")
self.assertEqual(my_graph.find_length_shortest_route("A", "B"), 5)
self.assertEqual(my_graph.find_length_shortest_route("A", "C"), 9)
self.assertEqual(my_graph.find_length_shortest_route("A", "D"), 5)
self.assertEqual(my_graph.find_length_shortest_route("A", "E"), 7)
self.assertEqual(my_graph.find_length_shortest_route("C", "D"), 8)
self.assertEqual(my_graph.find_length_shortest_route("D", "C"), 8)
self.assertEqual(my_graph.find_length_shortest_route("E", "B"), 3)
self.assertEqual(my_graph.find_length_shortest_route("A", "6"), "NO SUCH ROUTE")
self.assertEqual(my_graph.find_length_shortest_route("0", "C"), "NO SUCH ROUTE")
self.assertEqual(my_graph.find_length_shortest_route("foo", "bar"), "NO SUCH ROUTE")
self.assertEqual(my_graph.find_length_shortest_route(7, "z"), "NO SUCH ROUTE")
with self.assertRaises(Exception):
self.assertEqual(my_graph.find_length_shortest_route([], "C"), "NO SUCH ROUTE")
def _build(self, pattern=[], fragments_stack=[]):
if not pattern:
return
for c in pattern:
fragment = Fragment()
if c == expression.REGEX_NOTATION.CONCATENATION:
fragment_latter = fragments_stack.pop()
fragment_former = fragments_stack.pop()
for edge in fragment_former.out_edges:
edge.set_end(fragment_latter.start_node)
fragment.start_node = fragment_former.start_node
fragment.out_edges = fragment_latter.out_edges
elif c == expression.REGEX_NOTATION.OR:
fragment_branch_1 = fragments_stack.pop()
fragment_branch_2 = fragments_stack.pop()
node = graph.Node()
graph.Edge().set_start(node).set_end(
fragment_branch_1.start_node)
graph.Edge().set_start(node).set_end(
fragment_branch_2.start_node)
fragment.start_node = node
fragment.out_edges = fragment_branch_1.out_edges + fragment_branch_2.out_edges
elif c == expression.REGEX_NOTATION.REPEAT_MORE_THAN_ONE:
fragment_last = fragments_stack.pop()
node = graph.Node()
for edge in fragment_last.out_edges:
edge.set_end(node)
graph.Edge().set_start(node).set_end(fragment_last.start_node)
edge = graph.Edge()
edge.set_start(node)
fragment.start_node = fragment_last.start_node
fragment.out_edges.append(edge)
elif c == expression.REGEX_NOTATION.REPEAT_OR_ZERO:
fragment_last = fragments_stack.pop()
node = graph.Node()
for edge in fragment_last.out_edges:
edge.set_end(node)
graph.Edge().set_start(node).set_end(fragment_last.start_node)
edge = graph.Edge()
edge.set_start(node)
fragment.start_node = node
fragment.out_edges.append(edge)
elif c == expression.REGEX_NOTATION.ZERO_OR_ONE:
fragment_last = fragments_stack.pop()
node = graph.Node()
graph.Edge().set_start(node).set_end(fragment_last.start_node)
edge = graph.Edge()
edge.set_start(node)
fragment.start_node = node
fragment.out_edges = fragment_last.out_edges
fragment.out_edges.append(edge)
else:
node = graph.Node()
edge = graph.Edge(expression.MatchFunction(c))
edge.set_start(node)
fragment.start_node = node
fragment.out_edges.append(edge)
fragments_stack.append(fragment)
def add_edges(self, graph_nodes):
edges = []
for i in range(len(graph_nodes) - 1):
current_node_id = graph_nodes[i].id
edge = graph.Edge(graph_nodes[i], graph_nodes[i + 1], 'Right')
edges.append(edge)
return edges
def read_input_graph(self):
nums = self.read_numbers('Cannot parse the number of edges.', 1)
num_edges = nums[0]
if num_edges > config.MAX_NUM_EDGES:
raise self.exception('Number of edges cannot ' +
'exceed {0}.'.format(config.MAX_NUM_EDGES))
edge_set = set()
for i in range(num_edges):
nums = self.read_numbers('Cannot parse the next edge.', 2)
e = graph.Edge(nums[0], nums[1])
try:
e.check()
except graph.EdgeException as ex:
raise self.exception(str(ex))
if e in edge_set:
raise self.exception(('Edge {0} (or its reverse) ' +
'is duplicated.').format(e))
edge_set.add(e)
return edge_set
def create_edges(nodes_a_id, nodes_b_id, all_nodes):
edges = []
for node_a_id, node_b_id in zip(nodes_a_id, nodes_b_id):
node_a = nodes_dict[node_a_id]
node_b = nodes_dict[node_b_id]
edges.append(graph.Edge(node_a, node_b))
return edges
def testNewGraph(self):
#self.assertRaises(Exception, Graph)
g = graph.Graph("graph1")
n = graph.Node("node1")
e = graph.Edge(1, 2)
g.addnode("node2")
self.assertTrue(len(g.nodes) == 1)
def star_graph(n):
"""generate star graph n"""
g = graph.Graph()
ni = graph.Node()
for i in xrange(n):
n = graph.Node()
e = graph.Edge(ni, n)
g.add_edge(e)
return g
def pushed(self,
item: CDGRegionNode,
label: t.Optional[str] = None) -> t.Iterator[CDGRegionNode]:
if len(self) == 0:
assert item.type == CDGRegionNodeType.enter
else:
self.graph.add_edge(graph.Edge(self[-1], item, label))
self.append(item)
yield item
self.pop()
def test_get_route_distance(self):
my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7']
my_graph = graph.Graph(my_edge_list)
AE7 = graph.Edge("A", "E", 7)
EB3 = graph.Edge("E", "B", 3)
AB5 = graph.Edge("A", "B", 5)
DE6 = graph.Edge("D", "E", 6)
BC4 = graph.Edge("B", "C", 4)
CD8 = graph.Edge("C", "D", 8)
DC8 = graph.Edge("D", "C", 8)
CE2 = graph.Edge("C", "E", 2)
AD5 = graph.Edge("A", "D", 5)
self.assertEqual(my_graph.get_route_distance([AD5, DE6, EB3]), 14)
self.assertEqual(my_graph.get_route_distance([AD5, DC8, CD8, DE6, EB3]), 30)
self.assertEqual(my_graph.get_route_distance([]), 0)
self.assertEqual(my_graph.get_route_distance([AD5]), 5)
def t4():
g = G.Graph.empty_graph()
edge_list = [
G.Edge("n1", 1, "n2"),
G.Edge("n1", 1, "n3"),
G.Edge("n1", 1, "n4"),
G.Edge("n2", 1, "n3"),
G.Edge("n2", 1, "n4"),
G.Edge("n3", 1, "n4"),
G.Edge("n5", 1, "n6"),
G.Edge("n5", 1, "n7"),
G.Edge("n6", 1, "n7"),
G.Edge("n4", 1, "n6")
]
g.add_edge_list(edge_list)
simulation = Simulation(g, 1, 10)
simulation.simulate(100)
simulation.to_csv("output-t4.csv")
def add_tail(self,
tail: CFGNode,
label: t.Optional[str] = None) -> CFGEdge:
if label:
label = '{} - {}'.format(self.label,
label) if self.label else label
else:
label = self.label
edge = graph.Edge(self.head, tail, label)
self.graph.add_edge(edge)
return edge
def test_graph_build():
n1 = graph.Node()
n2 = graph.Node()
e = graph.Edge()
e.set_start(n1)
e.set_end(n2)
assert(e.start_node == n1)
assert(e.end_node == n2)
assert(e in n1.out_edges)
assert(e not in n1.in_edges)
assert(e in n2.in_edges)
assert(e not in n2.out_edges)
def add_edges(graph_nodes):
edges = []
for i in range(len(graph_nodes) - 1):
current_node_id = graph_nodes[i].id
edge = graph.Edge(graph_nodes[i], graph_nodes[i + 1], 'Right')
edges.append(edge)
for edge in edges:
print('----Edge----')
print(edge)
print(edge.node1.gt + ' - ' + edge.rel + ' - ' + edge.node2.gt)
return edges
def create_dense_graph(n, density):
g = G.Graph.empty_graph()
nodes = []
for i in range(n):
nodes.append(g.generate_new_node_name())
pairs = [(n1, n2) for n1 in nodes for n2 in nodes]
edges = [G.Edge(n1, 1, n2) for (n1, n2) in pairs if n1 != n2]
random.shuffle(edges)
if(density != 1):
edges = edges[ : int(-((1 - density) * len(edges)))]
for e in edges:
g.add_edge(e)
return g
def MakeGraph(cls, count, edge_tuples):
"""Makes a graph from a list of edges.
Args:
count: Number of nodes.
edge_tuples: (from_index, to_index). Both indices must be in [0, count),
and uniquely identify a node.
"""
nodes = [_IndexedNode(i) for i in xrange(count)]
edges = [
graph.Edge(nodes[from_index], nodes[to_index])
for (from_index, to_index) in edge_tuples
]
return (nodes, edges, graph.DirectedGraph(nodes, edges))
def t4(dim, r, a, f, degree):
g = G.Graph.empty_graph()
edge_list = [
G.Edge("n1", 1, "n2"),
G.Edge("n1", 1, "n3"),
G.Edge("n1", 1, "n4"),
G.Edge("n2", 1, "n3"),
G.Edge("n2", 1, "n4"),
G.Edge("n3", 1, "n4"),
G.Edge("n5", 1, "n6"),
G.Edge("n5", 1, "n7"),
G.Edge("n6", 1, "n7"),
G.Edge("n4", 1, "n6")
]
g.add_edge_list(edge_list)
simulation = Simulation(g, dim, 10, r, a, f, degree)
simulation.simulate(200)
file1 = "simulate-csv/degree-" + str(degree) + "/dim-" + str(
dim) + "/output-t4_" + str(r) + "_" + str(a) + "_" + str(f) + ".csv"
simulation.to_csv(file1)
print(file1)
def test_find_all_routes(self):
my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7']
my_graph = graph.Graph(my_edge_list)
AE7 = graph.Edge("A", "E", 7)
EB3 = graph.Edge("E", "B", 3)
AB5 = graph.Edge("A", "B", 5)
DE6 = graph.Edge("D", "E", 6)
BC4 = graph.Edge("B", "C", 4)
CD8 = graph.Edge("C", "D", 8)
DC8 = graph.Edge("D", "C", 8)
CE2 = graph.Edge("C", "E", 2)
AD5 = graph.Edge("A", "D", 5)
self.assertItemsEqual(my_graph.find_all_routes("A", "A"), [])
self.assertItemsEqual(my_graph.find_all_routes("A", "B"), [ [AE7, EB3], [AB5], [AD5, DE6, EB3], [AD5, DC8, CE2, EB3], [AD5, DC8, CD8, DE6, EB3] ])
self.assertItemsEqual(my_graph.find_all_routes("A", "6"), [])
self.assertItemsEqual(my_graph.find_all_routes("0", "C"), [])
self.assertItemsEqual(my_graph.find_all_routes("foo", "bar"), [])
self.assertItemsEqual(my_graph.find_all_routes(7, "z"), [])
with self.assertRaises(Exception):
self.assertItemsEqual(my_graph.find_all_routes([], "C"), [])
def __getEdge(self):
line = self.fobj.readline()
self.linecount+=1
pipe_info = line.split()
start = pipe_info[param.EDGE_INPUT['SRC']]
##print 'start-e',start
dst = pipe_info[param.EDGE_INPUT['DST']]
##print 'dst-e',dst
wt = int(pipe_info[param.EDGE_INPUT['WT']])
off_period = int(pipe_info[param.EDGE_INPUT['NOFF']])
j = param.EDGE_INPUT['NOFF']+1
off_list = []
for i in range(off_period):
off_list.append(pipe_info[j+i])
return graph.Edge(self.nodes[start], self.nodes[dst], wt, off_period, off_list)
def get_neighbors(self):
# for each grounded action
for ac in groundedActions:
# if the action is modeled in the state
if expressions.models(self.state,
expressions.make_expression(
ac.precondition)):
## apply the effect to the world
newstate = expressions.apply(
self.state, expressions.make_expression(ac.effect))
## add state to the neighbours list as an edge
nt = PlanNode(ac.name, newstate, self.objs)
ne = graph.Edge(nt, 1, ac.name)
self.neighbours.append(ne)
return self.neighbours
def test_get_number_routes_with_exactly_stops(self):
my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7']
my_graph = graph.Graph(my_edge_list)
AE7 = graph.Edge("A", "E", 7)
EB3 = graph.Edge("E", "B", 3)
AB5 = graph.Edge("A", "B", 5)
DE6 = graph.Edge("D", "E", 6)
BC4 = graph.Edge("B", "C", 4)
CD8 = graph.Edge("C", "D", 8)
DC8 = graph.Edge("D", "C", 8)
CE2 = graph.Edge("C", "E", 2)
AD5 = graph.Edge("A", "D", 5)
self.assertEqual(my_graph.get_number_routes_with_exactly_stops("A", "A", stops=5), 0)
self.assertEqual(my_graph.get_number_routes_with_exactly_stops("A", "B", stops=5), 3)
self.assertEqual(my_graph.get_number_routes_with_exactly_stops("A", "6", stops=5), 0)
self.assertEqual(my_graph.get_number_routes_with_exactly_stops("0", "C", stops=5), 0)
self.assertEqual(my_graph.get_number_routes_with_exactly_stops("foo", "bar", stops=5), 0)
self.assertEqual(my_graph.get_number_routes_with_exactly_stops(7, "z", stops=5), 0)
with self.assertRaises(Exception):
result = my_graph.get_number_routes_with_exactly_stops([], "C", stops=5)
self.assertEqual(result, 0)
def test_find_routes_with_distance(self):
my_edge_list = ['AB5', 'BC4', 'CD8', 'DC8', 'DE6', 'AD5', 'CE2', 'EB3', 'AE7']
my_graph = graph.Graph(my_edge_list)
AE7 = graph.Edge("A", "E", 7)
EB3 = graph.Edge("E", "B", 3)
AB5 = graph.Edge("A", "B", 5)
DE6 = graph.Edge("D", "E", 6)
BC4 = graph.Edge("B", "C", 4)
CD8 = graph.Edge("C", "D", 8)
DC8 = graph.Edge("D", "C", 8)
CE2 = graph.Edge("C", "E", 2)
AD5 = graph.Edge("A", "D", 5)
self.assertItemsEqual(my_graph.find_routes_with_distance("A", "A", distance=5), [])
self.assertItemsEqual(my_graph.find_routes_with_distance("A", "B", distance=11), [ [AE7, EB3], [AB5]])
self.assertItemsEqual(my_graph.find_routes_with_distance("A", "6", distance=5), [])
self.assertItemsEqual(my_graph.find_routes_with_distance("0", "C", distance=5), [])
self.assertItemsEqual(my_graph.find_routes_with_distance("foo", "bar", distance=5), [])
self.assertItemsEqual(my_graph.find_routes_with_distance(7, "z", distance=5), [])
with self.assertRaises(Exception):
result = my_graph.find_routes_with_distance([], "C", distance=5)
self.assertItemsEqual(result, [])
def read_output_graph(self, in_edge_set):
nums = self.read_numbers('Cannot parse the number of edges.', 1)
Gin = graph.make_graph(in_edge_set)
Gin.search()
if nums[0] != Gin.num_nodes - 1:
raise self.exception(
('Input graph has {0} non-isolated ' +
'nodes, output graph should have {1} edges, ' +
'got {2} instead.').format(Gin.num_nodes, Gin.num_nodes - 1,
nums[0]))
out_edge_set = set()
num_edges = nums[0]
for i in range(num_edges):
nums = self.read_numbers('Cannot parse the next edge.', 2)
e = graph.Edge(nums[0], nums[1])
if e not in in_edge_set:
raise self.exception(('Edge {0} in the output graph is ' +
'absent in the input graph.').format(e))
if e in out_edge_set:
raise self.exception(('Edge {0} (or its reverse) is ' +
'duplicated.').format(e))
out_edge_set.add(e)
Gout = graph.make_graph(out_edge_set)
Gout.search()
if Gout.num_nodes != Gin.num_nodes:
raise self.exception(
('After reading the last edge, the number ' +
'of non-isolated nodes in the output graph ({0}) ' +
'should equal that of the input graph ({1}) to be ' +
'a spanning tree.').format(Gout.num_nodes, Gin.num_nodes))
if not Gout.edges_in_one_component:
raise self.exception(
'Disconnected graph: after reading the last edge, the output graph should be connected to be a spanning tree.'
)
if Gout.has_cycle:
raise self.exception(
'Cycle detected: after reading the last edge, the output graph should not have cycles to be a spanning tree.'
)
return Gout.num_leaves
def create_cdg_loop(
loop: t.Union[ast.While, ast.For, ast.AsyncFor],
stack: CDGStack,
exit_node: CDGRegionNode,
res_graph: CDG,
) -> CDGNode:
if isinstance(loop, ast.While):
label = 'T'
name = 'While {}'.format(astor.to_source(loop.test).strip())
else:
label = 'Cont'
name = 'For {} in {}'.format(
astor.to_source(loop.target).strip(),
astor.to_source(loop.iter).strip())
lineno = -1
end_lineno = -1
if hasattr(loop, 'lineno'):
lineno = loop.lineno
# if hasattr(loop, 'end_lineno'):
# end_lineno = loop.end_lineno
loop_block = CDGRegionNode(loop,
CDGRegionNodeType.loop_block,
name,
lineno=lineno,
end_lineno=end_lineno)
with stack.pushed(loop_block):
loop_body = CDGRegionNode(ast.Pass(),
CDGRegionNodeType.loop_body,
lineno=lineno,
end_lineno=end_lineno)
res_graph.add_edge(graph.Edge(loop_body, loop_block, None))
with stack.pushed(loop_body, label):
process_block(loop.body, stack, exit_node, res_graph)
if loop.orelse:
with stack.pushed(
CDGRegionNode(ast.Pass(),
CDGRegionNodeType.else_block,
lineno=loop.lineno)):
process_block(loop.orelse, stack, exit_node, res_graph)
for breaked in loop_block.breaks:
stack.connect_to_next.append(breaked)
loop_block.breaks = []
return loop_block
def buildGraph(self):
'''
练习22.2-1
练习22.2-2
'''
g = _g.Graph()
g.veterxs = [_g.Vertex('1'), _g.Vertex('2'),
_g.Vertex('3'), _g.Vertex('4'),
_g.Vertex('5'), _g.Vertex('6')]
g.edges.clear()
g.edges.append(_g.Edge(_g.Vertex('1'), _g.Vertex('2'), 1, _g.DIRECTION_TO))
g.edges.append(_g.Edge(_g.Vertex('4'), _g.Vertex('2'), 1, _g.DIRECTION_TO))
g.edges.append(_g.Edge(_g.Vertex('1'), _g.Vertex('4'), 1, _g.DIRECTION_TO))
g.edges.append(_g.Edge(_g.Vertex('2'), _g.Vertex('5'), 1, _g.DIRECTION_TO))
g.edges.append(_g.Edge(_g.Vertex('3'), _g.Vertex('6'), 1, _g.DIRECTION_TO))
g.edges.append(_g.Edge(_g.Vertex('3'), _g.Vertex('5'), 1, _g.DIRECTION_TO))
g.edges.append(_g.Edge(_g.Vertex('5'), _g.Vertex('4'), 1, _g.DIRECTION_TO))
g.edges.append(_g.Edge(_g.Vertex('6'), _g.Vertex('6'), 1, _g.DIRECTION_TO))
_g.bfs(g, g.veterxs[2])
_g.print_path(g, g.veterxs[2], g.veterxs[4])
print('')
del g
g = _g.Graph()
g.veterxs.clear()
g.edges.clear()
v = ['r', 's', 't', 'u', 'v', 'w', 'x', 'y']
g.addvertex(v)
g.addedge('v', 'r')
g.addedge('r', 's')
g.addedge('s', 'w')
g.addedge('w', 'x')
g.addedge('w', 't')
g.addedge('x', 't')
g.addedge('x', 'u')
g.addedge('x', 'y')
g.addedge('y', 'u')
g.addedge('u', 't')
_g.bfs(g, 'u')
_g.print_path(g, 'u', 'v')
print('')
del g
def MakeGraph(cls, count, edge_tuples, serialize=False):
"""Makes a graph from a list of edges.
Args:
count: Number of nodes.
edge_tuples: (from_index, to_index). Both indices must be in [0, count),
and uniquely identify a node. Must be sorted
lexicographically by node indices.
"""
nodes = [_IndexedNode(i) for i in xrange(count)]
edges = [graph.Edge(nodes[from_index], nodes[to_index])
for (from_index, to_index) in edge_tuples]
g = graph.DirectedGraph(nodes, edges)
if serialize:
g = graph.DirectedGraph.FromJsonDict(
g.ToJsonDict(), _IndexedNode, graph.Edge)
nodes = sorted(g.Nodes(), key=operator.attrgetter('index'))
edges = sorted(g.Edges(), key=operator.attrgetter(
'from_node.index', 'to_node.index'))
return (nodes, edges, g)
