def __init__(self, vertices, use_pydot=False):
self.__verts__ = vertices
self.__adjmx__ = [[] for i in range(vertices)]
self.__arest__ = 0
if use_pydot:
self.__graph__ = Dot(graph_type='graph')
for i in range(vertices):
self.__graph__.add_node(Node(str(i)))
else:
self.__graph__ = None
def graph(self, model_classes):
graph = Dot(**self.graph_options)
relations = set()
# Create nodes from mappers
mappers = list(map(class_mapper, model_classes))
for mapper in mappers:
graph.add_node(
Node(
self.quote(mapper),
label=self.node_table(
mapper.class_.__name__,
self._model_columns(mapper),
self._model_operations(mapper),
),
**self.style["node"],
)
)
if mapper.inherits:
graph.add_edge(
Edge(
*map(self.quote, (mapper.inherits, mapper)),
**self.style["inheritance"],
)
)
for loader in mapper.iterate_properties:
if (
isinstance(loader, RelationshipProperty)
and loader.mapper in mappers
):
reverse = getattr(loader, "_reverse_property")
if len(reverse) == 1:
relations.add(frozenset((loader, next(iter(reverse)))))
else:
relations.add((loader,))
# Create edges from relationships between mappers
for relation in relations:
options = self.style["relationship"].copy()
if len(relation) == 2:
src, dest = relation
if src.viewonly and dest.viewonly:
options.update(self.style["relationship-viewonly"])
between = src.parent, dest.parent
options["headlabel"] = self._format_relationship(src)
options["taillabel"] = self._format_relationship(dest)
options["dir"] = "both"
else:
(prop,) = relation
between = prop.parent, prop.mapper
options["headlabel"] = self._format_relationship(prop)
if prop.viewonly:
options.update(self.style["relationship-viewonly"])
graph.add_edge(Edge(*map(self.quote, between), **options))
return graph
def render_graph(root, hierarchy, args):
g = Dot()
g.set_root(root[0])
for manager in hierarchy:
g.add_node(Node(manager[0], shape='box'))
for subordinate in hierarchy[manager]:
g.add_node(Node(subordinate[0], shape='box'))
g.add_edge(Edge(manager[0], subordinate[0]))
g.write_svg(args.file, args.imageType, args.layout)
def dump(self,file_name = None):
"""export to a png file"""
for nm in self.node_dict.keys():
self.get_node_by_name(nm).dumped = False
g = Dot()
for n in self.target_nodes:
n.dump_to(g)
from time import time
if file_name is None:
file_name = '_'.join([n.name for n in self.target_nodes])
file_name += '_%d.png'%(time()%100003)
g.write_png(file_name)
def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge
g = Dot()
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color='green'))
g.add_edge(Edge(str(node), str(node.false), color='red'))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
g.write_png('%s/%s.png' % (dname, name))
def make_pydot_graph(self, figname='tree'):
''' Use Graphviz to generate a graphical representation of the tree.
Args:
figname (str): where to store the figure.
'''
graph = Dot(graph_type='graph')
#graph.add_node(Node(self.root.display(),shape='diamond'))
edgelist = self.root.append_edgelist()
for edge in edgelist:
graph.add_node(edge[0])
graph.add_node(edge[1])
graph.add_edge(Edge(*edge))
graph.write_png(figname + '.png')
def RenderSIPCollection(sipGraph, dot=None):
try:
from pydot import Node, Edge, Dot
except:
import warnings
warnings.warn("Missing pydot library", ImportWarning)
if not dot:
dot = Dot(graph_type='digraph')
dot.leftNodesLookup = {}
nodes = {}
for N, prop, q in sipGraph.query(
'SELECT ?N ?prop ?q { ?prop a magic:SipArc . ?N ?prop ?q . }',
initNs={u'magic': MAGIC}):
if MAGIC.BoundHeadPredicate in sipGraph.objects(subject=N,
predicate=RDF.type):
NCol = [N]
else:
NCol = Collection(sipGraph, N)
if q not in nodes:
newNode = Node(makeMD5Digest(q),
label=normalizeTerm(q, sipGraph),
shape='plaintext')
nodes[q] = newNode
dot.add_node(newNode)
bNode = BNode()
nodeLabel = ', '.join([normalizeTerm(term, sipGraph) for term in NCol])
edgeLabel = ', '.join([
var.n3() for var in Collection(
sipGraph, first(sipGraph.objects(prop, MAGIC.bindings)))
])
markedEdgeLabel = ''
if nodeLabel in dot.leftNodesLookup:
bNode, leftNode, markedEdgeLabel = dot.leftNodesLookup[nodeLabel]
# print "\t",nodeLabel,edgeLabel, markedEdgeLabel,not edgeLabel == markedEdgeLabel
else:
leftNode = Node(makeMD5Digest(bNode),
label=nodeLabel,
shape='plaintext')
dot.leftNodesLookup[nodeLabel] = (bNode, leftNode, edgeLabel)
nodes[bNode] = leftNode
dot.add_node(leftNode)
if not edgeLabel == markedEdgeLabel:
edge = Edge(leftNode, nodes[q], label=edgeLabel)
dot.add_edge(edge)
return dot
def test_BioProvDocument():
"""
Tests the construction of an instance of BioProvDocument.
:return:
"""
# The BioProvDocument constructor with add_attributes=True
# is tested in the test_src_main.py module
prov = BioProvDocument(project)
# __repr__
assert str(prov).startswith("BioProvDocument")
# dot property
assert type(prov.dot) == Dot
prov.dot = Dot()
def plot_tree(sent_id):
global sentences
graph = Dot(graph_type='digraph')
basic_dependencies = sentences[sent_id].findall(
"./dependencies[@type='collapsed-dependencies']/dep")
for dep in basic_dependencies:
gov = "{}\n{}".format(dep[0].get("idx"), dep[0].text)
dep = "{}\n{}".format(dep[1].get("idx"), dep[1].text)
graph.add_node(Node(gov))
graph.add_node(Node(dep))
graph.add_edge(Edge(dep, gov))
graph.write_png(f"sentence_{sent_id}.png")
def main(input):
state_obj = yaml.load(input)
graph = Dot("states", graph_type='digraph')
rules = {
'require': {
'color': 'blue'
},
'require_in': {
'color': 'blue',
'reverse': True
},
'watch': {
'color': 'red'
},
'watch_in': {
'color': 'red',
'reverse': True
},
}
for top_key, props in state_obj.iteritems():
# Add a node for each state type embedded in this state
# keys starting with underscores are not candidates
if top_key == '__extend__':
# TODO - merge these into the main states and remove them
sys.stderr.write("Removing __extend__ states:\n{0}\n".format(
str(props)))
continue
for top_key_type, states in props.iteritems():
if top_key_type[:2] == '__':
continue
node_name = make_node_name(top_key_type, top_key)
graph.add_node(Node(node_name))
for edge_type, ruleset in rules.iteritems():
for relname in find_edges(states, edge_type):
if 'reverse' in ruleset and ruleset['reverse']:
graph.add_edge(
Edge(node_name, relname, color=ruleset['color']))
else:
graph.add_edge(
Edge(relname, node_name, color=ruleset['color']))
graph.write('/dev/stdout')
def __init__(self, functions):
self.node_dic = {}
self.edge_dic = {}
self.graph = Dot()
self.html = None
for f in functions:
if f.name in [
'slitherConstructorVariables',
'slitherConstructorConstantVariables'
]:
continue
self.construct_node(f)
self.construct_graph(functions)
self.html = svg_to_html(self.graph.create_svg().decode('utf-8'))
def visualize_fpta(red):
red_sorted = sorted(list(red), key=lambda x: len(x.prefix))
graph = Dot('fpta', graph_type='digraph')
for i, r in enumerate(red_sorted):
r.state_id = f'q{i}'
graph.add_node(Node(r.state_id, label=r.state_id))
for r in red_sorted:
for i, c in r.children.items():
graph.add_edge(Edge(r.state_id, c.state_id, label=i))
graph.add_node(Node('__start0', shape='none', label=''))
graph.add_edge(Edge('__start0', red_sorted[0].state_id, label=''))
return graph
def graph(nodes, name="HEX", dname="graphs", initial_player=Player.PLAYER_1):
g = Dot(graph_type="digraph", nodesep=0.5)
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
added = []
for node in nodes:
xlabel = str(node.owner) if node.owner is not None else ""
if xlabel == "both": xlabel = ""
g.add_node(pydot.Node(hash(node), label=node_str(node), shape="hexagon", width=0.1, height=0.1,
color=color_of_node(node), xlabel=xlabel))
for suc in node.neighbours:
if suc not in added:
g.add_edge(Edge(node.__hash__(), suc.__hash__(), color=color_of_node(suc, True), arrowhead="None"))
added.append(node)
g.write_png('%s/%s.png' % (dname, name), prog='neato')
def draw(self, prob, targetFile):
# Do the graphing stuff here...
# Root graph
g = Dot(graph_type="digraph", nodesep=2, overlap=False)
#g.set_edge_defaults(weight="0", minlen="10")
# Organise by adding constraints (adds edges too)
for constr in prob.constrs:
# Node for constraint
constrNode = Node(constr.name, shape="ellipse", style="filled", fillcolor = "#aaaaff")
constrNode.set_label(constr.name + ": " + constr.getTextFormula())
g.add_node(constrNode)
# Associated expressions
for expr in constr.exprs:
self.addNodesForChildren(g, expr, constr)
# Finally, render
#g.write_png("problem_structure.png", prog="dot")
g.write_png(targetFile, prog="neato")
def renderNetwork(network, nsMap={}):
"""
Takes an instance of a compiled ReteNetwork and a namespace mapping (for constructing QNames
for rule pattern terms) and returns a BGL Digraph instance representing the Rete network
#(from which GraphViz diagrams can be generated)
"""
# from FuXi.Rete import BuiltInAlphaNode
# from BetaNode import LEFT_MEMORY, RIGHT_MEMORY, LEFT_UNLINKING
dot = Dot(graph_type='digraph')
namespace_manager = NamespaceManager(Graph())
for prefix, uri in list(nsMap.items()):
namespace_manager.bind(prefix, uri, override=False)
visitedNodes = {}
edges = []
idx = 0
for node in list(network.nodes.values()):
if node not in visitedNodes:
idx += 1
visitedNodes[node] = generateBGLNode(dot, node, namespace_manager,
str(idx))
dot.add_node(visitedNodes[node])
nodeIdxs = {}
for node in list(network.nodes.values()):
for mem in node.descendentMemory:
if not mem:
continue
bNode = mem.successor
for bNode in node.descendentBetaNodes:
for idx, otherNode in enumerate([bNode.leftNode, bNode.rightNode]):
if node == otherNode and (node, otherNode) not in edges:
for i in [node, bNode]:
if i not in visitedNodes:
idx += 1
nodeIdxs[i] = idx
visitedNodes[i] = generateBGLNode(
dot, i, namespace_manager, str(idx))
dot.add_node(visitedNodes[i])
edge = Edge(visitedNodes[node],
visitedNodes[bNode],
label=idx == 0 and 'left' or 'right')
dot.add_edge(edge)
edges.append((node, bNode))
return dot
def indiv_with_sub(df, outfolder):
thislist, deptlist = get_reports(df)
for x in list(set([i[1] for i in thislist])):
graph = Dot(graph_type='graph',
ratio='auto',
size=150,
dpi=150,
splines='ortho')
#people who report to x
reports = [y for y in thislist if y[1] == x]
#and the people they report to
reports2 = [y for y in thislist if y[1] in [z[0] for z in reports]]
reporting = reports + reports2
reporting = list(set(reporting))
for report_to, report in reporting:
graph.add_edge(Edge(report, report_to))
print(f"Now writing file for {x}")
graph.write_png(f"{outfolder}\\{x}.png")
def build_graph_parser(subparsers):
try:
from pydot import Dot
formats = Dot().formats
except ImportError:
return
p_graph = subparsers.add_parser(
'graph',
help='Build a graph from the XML tags relationships.',
description='Build a graph from the XML tags relationships.')
def act(ns):
extension = ns.outfile.split('.')[-1]
if ns.format:
if extension != ns.format:
ns.outfile += '.' + ns.format
else:
if extension in formats:
ns.format = extension
root = etree.parse(ns.infile).getroot()
write_tag_graph(ns.path(root), ns.outfile, ns.format)
p_graph.set_defaults(action=act)
p_graph.add_argument('--format',
choices=formats,
metavar='FORMAT',
help='The format for the graph image.\n'
'It will be appended to the filename '
'unless they already concur '
'or -F is passed.\n'
'Choose from ' + str(formats))
p_graph.add_argument('-F',
'--force-extension',
help='Allow the filename extension to differ '
'from the file format.\n'
'Without this option, the format extension '
'will be appended to the filename.')
p_graph.add_argument(dest='outfile',
default=None,
help='The filename for the graph image.\n'
'If no --format is given, '
'it will be based on this name.')
def __init__(self, _contract: Contract):
"""
Takes a Contract object and constructs the DDG for it.
*** To be completed
Currently cannot detect indirect read.
Indirect write can be detected.
"""
self.contract = _contract
self.node_dic = {}
self.edge_dic = {}
self.graph = Dot()
for f in _contract.functions + _contract.constructor_as_list:
if f.name in ['slitherConstructorVariables', 'slitherConstructorConstantVariables'] or not f.is_public_or_external:
continue
self.construct_node(f)
self.construct_graph(_contract)
def make_pydot(nodes, edges, direction='LR', sep='_', **kwargs):
from pydot import Dot, Cluster, Node, Edge
class Subgraphs(dict):
def __missing__(self, path):
*parent, label = path
subgraph = Cluster(sep.join(path), label=label, style='rounded, filled', fillcolor='#77777744')
self[tuple(parent)].add_subgraph(subgraph)
return subgraph
g = Dot(rankdir=direction, directed=True, **kwargs)
g.set_node_defaults(
shape='box', style='rounded, filled', fillcolor='#ffffff')
subgraphs = Subgraphs({(): g})
for path, attr in nodes:
*parent, label = path.split(sep)
subgraphs[tuple(parent)].add_node(
Node(name=path, label=label, **attr))
for src, dst, attr in edges:
g.add_edge(Edge(src, dst, **attr))
return g
def plant2dot(plantinfo):
qn = str(plantinfo.plant._qname)
# Create the hierarchical graph with all the nodes (no edges for now)
plantd = Dot(qn,
simplify=True,
comment="Generated by radler for {}".format(qn))
v = AstVisitor({'node' : node,
'lynxsecure_vm' : machine,
'certikos_vm' : machine,
'machine' : machine },
onleaf=follow_links(AstVisitor.leaf_bf), #@UndefinedVariable
kind='bf')
v.visit(plantinfo.plant, plantd)
# Add all edges
for cl in plantinfo.channels.values():
for c in cl:
if c.incoming:
plantd.add_edge(Edge(str(c.pub), str(c.sub)))
print(plantd.to_string())
def leveler(df):
thislist, deptlist = get_reports(df)
newdict = {"Berenecea Johnson-Eanes": 1}
newdict.update({x[0]: 0 for x in thislist})
while True:
if len([value for value in newdict.values() if value == 0]) == 0:
break
for person in newdict.keys():
if newdict[person] == 0:
try:
if newdict[[x[1] for x in thislist
if x[0] == person][0]] == 0:
pass
else:
newnum = newdict[[
x[1] for x in thislist if x[0] == person
][0]] + 1
newdict.update({person: newnum})
except:
print(f'{person} not found')
else:
pass
for i in range(max([value for value in newdict.values()])):
graph = Dot(graph_type='graph',
ratio='.3',
size=150,
dpi=150,
splines='ortho')
#graph.set_node_defaults(style="filled", fillcolor="grey")
graph.set_edge_defaults(color="blue", arrowhead="vee", weight="1")
for report_to, report in thislist:
try:
if newdict[report_to] in [
i, i + 1, i + 2
] or newdict[report] in [i, i + 1, i + 2]:
graph.add_edge(Edge(report, report_to))
except:
print(report_to, report)
#graph.write("c:\\users\\shane\\desktop\\out.dot")
graph.write_png(f"c:\\users\\shane\\desktop\\orgcharts\\level{i}.png")
def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge, Node
g = Dot()
g.set_node_defaults(color='lightgray',
style='filled',
shape='box',
fontname='Courier',
fontsize='10')
if len(self.nodes) == 1:
g.add_node(Node(str(self.nodes[0])))
else:
for node in sorted(self.nodes, key=lambda x: x.num):
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
for except_node in self.catch_edges.get(node, []):
g.add_edge(
Edge(str(node),
str(except_node),
color='black',
style='dashed'))
g.write_png('%s/%s.png' % (dname, name))
def graph_representation(self):
"""
Construct a dot graph representation of these results.
:return: The dot graph
"""
from pydot import Dot, Edge, Node
g = Dot()
for r in self.resources:
g.add_node(
Node('i_' + r,
label='{:.3} {}'.format(
float(self.produced(r) + self.supplied(r)), r),
style='dashed'))
for recipe, batches in self.recipes.items():
g.add_node(
Node('r_' + recipe,
label='{:.3} {}'.format(batches[1], recipe),
shape='box'))
r: Recipe = self.book[recipe]
for output in r.outputs():
weight = r.produced(output, batches[1])
g.add_edge(
Edge('r_' + recipe,
'i_' + output,
label='{:.3}'.format(weight),
weight=weight))
for input in r.inputs():
weight = r.consumed(input, batches[1])
g.add_edge(
Edge('i_' + input,
'r_' + recipe,
label='{:.3}'.format(weight),
weight=weight))
return g
def save(self, cfg, filename, print_ir=False, format='dot', options=None):
"""Save basic block graph into a file.
"""
if options is None:
options = {}
try:
dot_graph = Dot(**self.graph_format)
# Add nodes.
nodes = {}
for bb in cfg.basic_blocks:
nodes[bb.address] = self._create_node(bb, cfg.name, print_ir,
options)
dot_graph.add_node(nodes[bb.address])
# Add edges.
for bb_src in cfg.basic_blocks:
for bb_dst_addr, branch_type in bb_src.branches:
if bb_dst_addr in nodes:
edge = self._create_edge(nodes[bb_src.address],
nodes[bb_dst_addr],
branch_type)
dot_graph.add_edge(edge)
else:
logger.warning(
"Destination basic block not found! (0x%x)",
bb_dst_addr)
# Save graph.
dot_graph.write("{}.{}".format(filename, format), format=format)
except Exception:
logger.error("Failed to save basic block graph: %s (%s)",
filename,
format,
exc_info=True)
def graph_representation(self):
"""
Construct a dot graph representation of these results.
:return: The dot graph
"""
from pydot import Dot, Edge, Node
g = Dot()
for resource in self.resources:
color = 'black'
if resource in self.targets and self.consumed(resource) == 0:
color = 'darkgreen'
elif self.consumed(resource) == 0:
color = 'brown'
g.add_node(Node('i_' + resource, label='{:.3} {}'.format(float(self.produced(resource) + self.supplied(resource)), resource), color=color, style='dashed'))
if resource in self.targets and self.consumed(resource) > 0:
# add a second node if requested and consumed so we can see a terminal node
g.add_node(Node('ir_' + resource, label='{:.3} {}'.format(float(self.requested(resource)), resource), color='darkgreen', style='dashed'))
weight = self.requested(resource)
g.add_edge(Edge('i_' + resource, 'ir_' + resource, label='{:.3}'.format(weight), weight=weight))
for recipe, batches in self.recipes.items():
if self.book.crafters_defined():
crafter = self.book.get_crafter_for(recipe) or Crafter('', 1)
label = '{:.3} {}\n{}'.format(batches[1], crafter.name, recipe)
else:
label = '{:.3} {}'.format(batches[1], recipe)
g.add_node(Node('r_' + recipe, label=label, shape='box'))
r: Recipe = self.book[recipe]
for output in r.outputs():
weight = r.produced(output, batches[1])
g.add_edge(Edge('r_' + recipe, 'i_' + output, label='{:.3}'.format(weight), weight=weight))
for input in r.inputs():
weight = r.consumed(input, batches[1])
g.add_edge(Edge('i_' + input, 'r_' + recipe, label='{:.3}'.format(weight), weight=weight))
return g
def graph(self, tables, skip_tables=()):
graph = Dot(**self.graph_options)
for table in tables:
if table.name in skip_tables:
continue
graph.add_node(
Node(
self.quote(table.name),
label=self.node_table(
table.name,
self._table_columns(table),
self._table_indices(table),
),
**self.style["node"],
)
)
for fk in table.foreign_keys:
fk_table = fk.column.table
if fk_table not in tables or fk_table.name in skip_tables:
continue
is_single_parent = fk.parent.primary_key or fk.parent.unique
options = self.style["edge"].copy()
options["arrowtail"] = "empty" if is_single_parent else "crow"
options["dir"] = "both"
if fk.parent.primary_key and fk.column.primary_key:
# Inheritance relationship
edge = fk_table.name, table.name
options["arrowhead"] = "none"
options["tailport"] = fk.column.name
options["headport"] = fk.parent.name
else:
edge = table.name, fk_table.name
options["arrowhead"] = "odot"
options["tailport"] = fk.parent.name
options["headport"] = fk.column.name
graph.add_edge(Edge(*map(self.quote, edge), **options))
return graph
def save(self, cf, filename, format='dot'):
"""Save basic block graph into a file.
"""
try:
dot_graph = Dot(**self.graph_format)
# add nodes
nodes = {}
for cfg_addr in cf._graph.node.keys():
nodes[cfg_addr] = self._create_node(cfg_addr, cf)
dot_graph.add_node(nodes[cfg_addr])
# add edges
for cfg_src_addr in cf._graph.node.keys():
for cfg_dst_addr in cf._edges.get(cfg_src_addr, []):
edge = self._create_edge(nodes, cfg_src_addr, cfg_dst_addr)
dot_graph.add_edge(edge)
dot_graph.write("{}.{}".format(filename, format), format=format)
except Exception as err:
logger.error("Failed to save call graph: %s (%s)", filename, format, exc_info=True)
def visualize_pta(root_node, path='pta.pdf'):
from pydot import Dot, Node, Edge
graph = Dot('fpta', graph_type='digraph')
graph.add_node(Node(str(root_node.prefix), label=f'{root_node.output}'))
queue = [root_node]
visited = set()
visited.add(root_node.prefix)
while queue:
curr = queue.pop(0)
for i, c in curr.children.items():
if c.prefix not in visited:
graph.add_node(Node(str(c.prefix), label=f'{c.output}'))
graph.add_edge(Edge(str(curr.prefix), str(c.prefix), label=f'{i}'))
if c.prefix not in visited:
queue.append(c)
visited.add(c.prefix)
graph.add_node(Node('__start0', shape='none', label=''))
graph.add_edge(Edge('__start0', str(root_node.prefix), label=''))
graph.write(path=path, format='pdf')
def draw_pydot(nodes, edges, direction='LR', **kwargs):
def make_subgraph(path, parent_graph):
subgraph = Cluster(path,
label=split(path)[1],
style='rounded, filled',
fillcolor='#77777744')
parent_graph.add_subgraph(subgraph)
return subgraph
subgraphs = cache(
lambda path: make_subgraph(path, subgraphs[parent(path)]))
subgraphs[''] = g = Dot(rankdir=direction, directed=True, **kwargs)
g.set_node_defaults(shape='box',
style='rounded, filled',
fillcolor='#ffffff')
for node, path, attr in nodes:
p, stub = split(path)
subgraphs[p].add_node(Node(name=node, label=stub, **attr))
for src, dst, attr in edges:
g.add_edge(Edge(src, dst, **attr))
return g.create_svg()
def show_diagram(self, path=None):
"""
Creates the graph associated with this DFA
"""
# Nodes are set of states
graph = Dot(graph_type='digraph', rankdir='LR')
nodes = {}
for state in self.states:
if state == self.initial_state:
# color start state with green
if state in self.final_states:
initial_state_node = Node(state,
style='filled',
peripheries=2,
fillcolor='#66cc33')
else:
initial_state_node = Node(state,
style='filled',
fillcolor='#66cc33')
nodes[state] = initial_state_node
graph.add_node(initial_state_node)
else:
if state in self.final_states:
state_node = Node(state, peripheries=2)
else:
state_node = Node(state)
nodes[state] = state_node
graph.add_node(state_node)
# adding edges
for from_state, lookup in self.transitions.items():
for to_label, to_state in lookup.items():
graph.add_edge(
Edge(nodes[from_state], nodes[to_state], label=to_label))
if path:
graph.write_png(path)
return graph
