def plot_tree(tree, name):
""" Plot and generate a png image of a tree with the tree hashed name
Args:
tree (dict): A dictionary contains all information of a tree
name (str): The hashed name of the tree
"""
graph = pydot.Dot(graph_type='graph')
tree_graph = pydot.Cluster(
graph_name="Learner Tree",
label="Learner Tree",
fontsize="15",
)
graphlegend = pydot.Cluster(graph_name="legend",
label="Legend",
fontsize="15",
rankdir="LR")
legends = []
for NODE_KEY in list(NODE_TYPES.keys()):
legend = pydot.Node(NODE_KEY,
style="filled",
fillcolor=NODE_COLOR_DICT[NODE_KEY],
rank="same")
graphlegend.add_node(legend)
legends.append(legend)
walk_dictionary(tree_graph, tree)
graph.add_subgraph(tree_graph)
graph.add_subgraph(graphlegend)
for legend_index in range(1, len(legends)):
graph.add_edge(
pydot.Edge(legends[legend_index - 1],
legends[legend_index],
style="invis"))
graph.write_png('./' + name + '.png')
def _add_node(diagram: Union[pydot.Dot, pydot.Cluster], op: Union[Op, Trace], node_id: str) -> None:
"""Draw a node onto a diagram based on a given op.
Args:
diagram: The diagram to be appended to.
op: The op (or trace) to be visualized.
node_id: The id to use as the node label.
"""
if isinstance(op, Sometimes) and op.numpy_op:
wrapper = pydot.Cluster(style='loosely dotted', graph_name=str(id(op)))
wrapper.set('label', f'Sometimes ({op.prob}):')
wrapper.set('labeljust', 'r')
Traceability._add_node(wrapper, op.numpy_op, node_id)
diagram.add_subgraph(wrapper)
elif isinstance(op, OneOf) and op.numpy_ops:
wrapper = pydot.Cluster(style='loosely dotted', graph_name=str(id(op)))
wrapper.set('label', 'One Of:')
wrapper.set('labeljust', 'r')
Traceability._add_node(wrapper, op.numpy_ops[0], node_id)
for sub_op in op.numpy_ops[1:]:
Traceability._add_node(wrapper, sub_op, str(id(sub_op)))
diagram.add_subgraph(wrapper)
else:
if isinstance(op, ModelOp):
label = f"{op.__class__.__name__} ({FEID(id(op))}): {op.model.model_name}"
model_ref = Hyperref(Marker(name=str(op.model.model_name), prefix='subsec'),
text=NoEscape(r'\textcolor{blue}{') + bold(op.model.model_name) +
NoEscape('}')).dumps()
texlbl = f"{HrefFEID(FEID(id(op)), name=op.__class__.__name__).dumps()}: {model_ref}"
else:
label = f"{op.__class__.__name__} ({FEID(id(op))})"
texlbl = HrefFEID(FEID(id(op)), name=op.__class__.__name__).dumps()
diagram.add_node(pydot.Node(node_id, label=label, texlbl=texlbl))
def drawOmciSession():
dot_object = pydot.Dot(graph_type='digraph',
rankdir="LR",
labelloc='b',
ranksep=4,
nodesep=0.2,
splines='true')
dot_object.set_node_defaults(shape='circle',
fixedsize='true',
height=.2,
width=.2,
fontsize=6)
plate_olt = pydot.Cluster(graph_name='OLT',
label='OLT',
fontsize=12,
color='black',
lp=1)
plate_onu = pydot.Cluster(graph_name='ONU',
label='ONU',
fontsize=12,
color='black')
j = 1
while (j < len(MS) * 2 + 1):
if j % 2 == 1:
label_seq = str(int((j + 1) / 2))
plate_olt.add_node(
pydot.Node(name=str(j), color="black", label=label_seq))
else:
plate_onu.add_node(pydot.Node(name=str(j), color="black",
label=""))
j = j + 1
k = 1
while (k < len(MS) * 2 + 1):
index = int(k / 2)
try:
label_text = MS[index] + " " + ME[index] + " " + ID[
index] + " " + INFO[index]
except IndexError:
print("Index out of range...")
break
xdir = "forword"
if "RESPONSE" in MS[index]:
xdir = "back"
dot_object.add_edge(
pydot.Edge(pydot.Node(name=str(k)),
pydot.Node(name=str(k + 1)),
label=label_text,
dir=xdir,
fontsize=6))
k = k + 2
dot_object.add_subgraph(plate_olt)
dot_object.add_subgraph(plate_onu)
dot_object.write('graph.dotfile', format='raw', prog='dot')
dot_object.write_pdf('omci_session.pdf', prog='dot')
def drawGrafFunkcjaPlikPar(self):
fundata = self.fundata1
n1 = 0
m1 = 0
for name1 in fundata:
if (name1 != "data.json" and name1 != "func.json"
and name1 != "cls.json" and name1 != "relfunc.json"):
n1 = pydot.Cluster(label=name1, style="filled", color="white")
n1.add_node(
pydot.Node(name1,
label=name1,
shape="circle",
style="filled",
fillcolor="darkgoldenrod1"))
self.graph1.add_subgraph(n1)
for p1 in fundata[name1]:
m1 = pydot.Cluster(label=p1, style="filled", color="white")
m1.add_node(
pydot.Node(p1,
label=p1,
shape="circle",
style="filled",
fillcolor="darkgoldenrod3"))
self.graph1.add_subgraph(m1)
self.graph1.add_edge(pydot.Edge(name1, p1,
fontsize="10.0"))
else:
wd40 = 0
def drawGrafModuluPar(self):
clsdata = self.clsdata1
fundata = self.fundata1
z = 0
x = 0
str = "z"
str2 = "x"
for namec in clsdata:
if (namec != "data.json" and namec != "func.json"
and namec != "cls.json" and namec != "relfunc.json"):
for pc in clsdata[namec]:
z = pydot.Cluster(label=pc, style="filled", color="white")
a = pc + str
z.add_node(
pydot.Node(a,
label=pc,
shape="circle",
style="filled",
fillcolor="antiquewhite"))
self.graph1.add_subgraph(z)
else:
wd40 = 0
for pc in fundata[namec]:
x = pydot.Cluster(label=pc, style="filled", color="white")
b = pc + str2
x.add_node(
pydot.Node(b,
label=pc,
shape="circle",
style="filled",
fillcolor="antiquewhite3"))
self.graph1.add_subgraph(x)
self.graph1.add_edge(pydot.Edge(a, b, fontsize="10.0"))
def get_policy_graph(policy):
graph = pydot.Dot('ordered',
graph_type='digraph',
compound='true',
fontname='Times',
fontsize=20)
gcontexts = pydot.Cluster('context', rank='same', label='Contexts')
gcommands = pydot.Cluster('commands', rank='same', label='Commands')
graph.add_subgraph(gcommands)
graph.add_subgraph(gcontexts)
for cmd in set(policy.values()):
gcommands.add_node(pydot.Node(cmd))
stategroup = {}
for (state, obsset), cmd in policy.items():
if not state in stategroup:
stategroup[state] = pydot.Cluster('state%s' % str(state),
label=state)
gcontexts.add_subgraph(stategroup[state])
for (state, obsset), cmd in policy.items():
n = '%s, %s' % (state, obsset)
parent = gcontexts
parent = stategroup[state]
parent.add_node(pydot.Node(n, label=obsset))
# graph.add_edge(pydot.Edge(n, cmd,
# ltail=gcontexts.get_name(),
# lhead=gcommands.get_name()))
graph.add_edge(pydot.Edge(n, cmd))
return graph
def test_edge_point_object_cluster(self):
self._reset_graphs()
self.graph_directed.add_edge(pydot.Edge(pydot.Cluster('a'),
pydot.Cluster('b')))
self.assertEqual(
self.graph_directed.get_edges()[0].to_string(),
'cluster_a -> cluster_b;')
def to_pydot(self, channels=True):
"""Convert the mapping to a dot graph
The generated graph visualizes how a dataflow application is mapped
to a platform.
:returns: pydot object
"""
dot = pydot.Dot(graph_type="digraph")
processor_clusters = {}
for s in self.platform.schedulers():
cluster = pydot.Cluster("scheduler_" + s.name, label=s.name)
dot.add_subgraph(cluster)
for p in s.processors:
p_cluster = pydot.Cluster("processor_" + p.name, label=p.name)
p_cluster.add_node(pydot.Node("dummy_" + p.name,
style="invis"))
processor_clusters[p.name] = p_cluster
cluster.add_subgraph(p_cluster)
primitive_nodes = {}
if channels:
for p in self.platform.primitives():
if p.name not in primitive_nodes:
node = pydot.Node("primitive_" + p.name, label=p.name)
dot.add_node(node)
primitive_nodes[p.name] = node
process_nodes = {}
for p in self.graph.processes():
info = self._process_info[p.name]
p_cluster = processor_clusters[info.affinity.name]
node = pydot.Node("process_" + p.name, label=p.name)
process_nodes[p.name] = node
p_cluster.add_node(node)
channel_nodes = {}
if channels:
for c in self.graph.channels():
node = pydot.Node("channel_" + c.name,
label=c.name,
shape="diamond")
channel_nodes[c.name] = node
dot.add_node(node)
from_node = process_nodes[c.source.name]
dot.add_edge(pydot.Edge(from_node, node, minlen=4))
for p in c.sinks:
to_node = process_nodes[p.name]
dot.add_edge(pydot.Edge(node, to_node, minlen=4))
info = self._channel_info[c.name]
prim_node = primitive_nodes[info.primitive.name]
dot.add_edge(
pydot.Edge(node,
prim_node,
style="dashed",
arrowhead="none"))
return dot
def add_children_and_edges(root, root_node, root_dot_name,
visibility_level, collapse_decorators, sub):
if isinstance(root, decorators.Decorator) and collapse_decorators:
return
if visibility_level < root.blackbox_level:
node_names = []
for c in root.children:
(node_shape, node_colour,
node_font_colour) = get_node_attributes(c)
node_name = c.name
while node_name in behaviour_id_name_map.values():
node_name += "*"
behaviour_id_name_map[c.id] = node_name
# Node attributes can be found on page 5 of
# https://graphviz.gitlab.io/_pages/pdf/dot.1.pdf
# Attributes that may be useful: tooltip, xlabel
node = pydot.Node(
name=node_name,
label=get_node_label(node_name, c),
shape=node_shape,
style="filled",
fillcolor=node_colour,
fontsize=fontsize,
fontcolor=node_font_colour,
)
node_names.append(node_name)
if root.blackbox_level == common.BlackBoxLevel.COMPONENT:
if sub is not None:
subgraph = pydot.Cluster(graph_name=root_dot_name,
label=root_dot_name,
style='dotted')
sub.add_subgraph(subgraph)
subgraph.add_node(node)
edge = pydot.Edge(root_dot_name, node_name)
subgraph.add_edge(edge)
else:
subgraph = pydot.Cluster(graph_name=root.name,
label=root.name,
style='dotted')
graph.add_subgraph(subgraph)
subgraph.add_node(node)
edge = pydot.Edge(root_dot_name, node_name)
subgraph.add_edge(edge)
elif sub is not None:
sub.add_node(node)
edge = pydot.Edge(root_dot_name, node_name)
sub.add_edge(edge)
subgraph = sub
else:
subgraph = None
graph.add_node(node)
edge = pydot.Edge(root_dot_name, node_name)
graph.add_edge(edge)
if c.children != []:
add_children_and_edges(c, node, node_name,
visibility_level,
collapse_decorators, subgraph)
def add_edge(self, groupsrc, groupdst, arrowhead='normal', dir='forward'):
scluster = pydot.Cluster(str(groupsrc.channel))
s = pydot.Node(str(groupsrc.name))
scluster.add_node(s)
dcluster = pydot.Cluster(str(groupdst.channel))
d = pydot.Node(str(groupdst.name))
dcluster.add_node(d)
self.graph.add_subgraph(dcluster)
self.graph.add_subgraph(scluster)
e = pydot.Edge(s, d, arrowhead=arrowhead, dir=dir)
self.graph.add_edge(e)
def writePopulationDot(ga_engine, filename, format="jpeg", start=0, end=0):
""" Writes to a graphical file using pydot, the population of trees
Example:
>>> GTreeGP.writePopulationDot(ga_engine, "pop.jpg", "jpeg", 0, 10)
This example will draw the first ten individuals of the population into
the file called "pop.jpg".
:param ga_engine: the GA Engine
:param filename: the filename, ie. population.jpg
:param start: the start index of individuals
:param end: the end index of individuals
"""
if not HAVE_PYDOT:
utils.raiseException("You must install Pydot to use this feature !")
pop = ga_engine.get_population()
graph = pydot.Dot(graph_type="digraph")
if not isinstance(pop[0], GTreeGP):
utils.raiseException("The population must have individuals of the GTreeGP chromosome !")
n = 0
end_index = len(pop) if end == 0 else end
for i in xrange(start, end_index):
ind = pop[i]
subg = pydot.Cluster(
"cluster_%d" % i,
label="\"Ind. #%d - Score Raw/Fit.: %.4f/%.4f\"" % (i, ind.getRawScore(), ind.getFitnessScore())
)
n = ind.writeDotGraph(subg, n)
graph.add_subgraph(subg)
graph.write(filename, prog='dot', format=format)
def _draw_subgraph(diagram: pydot.Dot,
label_last_seen: DefaultDict[str, str],
subgraph_name: str,
subgraph_ops: List[Union[Op, Trace, Any]]) -> None:
"""Draw a subgraph of ops into an existing `diagram`.
Args:
diagram: The diagram to be appended to.
label_last_seen: A mapping of {data_dict_key: node_id} indicating the last node which generated the key.
subgraph_name: The name to be associated with this subgraph.
subgraph_ops: The ops to be wrapped in this subgraph.
"""
subgraph = pydot.Cluster(style='dashed', graph_name=subgraph_name)
subgraph.set('label', subgraph_name)
subgraph.set('labeljust', 'l')
for idx, op in enumerate(subgraph_ops):
node_id = str(id(op))
Traceability._add_node(subgraph, op, node_id)
if isinstance(op, (Op, Trace)):
# Need the instance check since subgraph_ops might contain a tf dataset or torch dataloader
edge_srcs = defaultdict(lambda: [])
for inp in op.inputs:
if inp == '*':
continue
edge_srcs[label_last_seen[inp]].append(inp)
for src, labels in edge_srcs.items():
diagram.add_edge(pydot.Edge(src=src, dst=node_id, label=f" {', '.join(labels)} "))
for out in op.outputs:
label_last_seen[out] = node_id
if isinstance(op, Trace) and idx > 0:
# Invisibly connect traces in order so that they aren't all just squashed horizontally into the image
diagram.add_edge(pydot.Edge(src=str(id(subgraph_ops[idx - 1])), dst=node_id, style='invis'))
diagram.add_subgraph(subgraph)
def draw_modular(self, loc='test_mod.pdf'):
nn = self.individual.nn
Qscore, groups = Q(nn)
g = pydot.Dot(graph_type='digraph', ranksep='0.5 equally', nodesep=0.2)
g.set_node_defaults(shape='circle',style='filled')
inputs = pydot.Subgraph('inputs',graph_type='digraph',rank='source')
outputs = pydot.Subgraph('outputs',graph_type='digraph',rank='same')
g.add_subgraph(inputs)
g.add_subgraph(outputs)
for i in range(nn.input_size):
inputs.add_node(pydot.Node(str(i), label='input'+str(i)))
if (i > 0):
inputs.add_edge(pydot.Edge(str(i - 1), str(i), style='invis'))
for i in range(nn.input_size, nn.input_size + nn.output_size):
outputs.add_node(pydot.Node(str(i), label='output'+str(i - nn.input_size)))
if (i > nn.input_size):
outputs.add_edge(pydot.Edge(str(i - 1), str(i), style='invis'))
count = -1
for group in groups:
count += 1
random_number = random.randint(0,16777215)
hex_color = str(hex(random_number))
hex_color = '#' + hex_color[2:]
cluster = pydot.Cluster('c' + str(count))
for n in group:
if (n >= nn.input_size + nn.output_size):
cluster.add_node(pydot.Node(str(n), fillcolor= hex_color))
g.add_subgraph(cluster)
edges = tuple(zip(nn.connList.connSource, nn.connList.connTarget))
for e in edges:
g.add_edge(pydot.Edge(str(e[0]), str(e[1])))
g.write(loc, format='pdf')
def get_legend(subgraph, name, show_ic=False, **kwargs):
legend = pydot.Cluster(graph_type="digraph",
graph_name="Legend",
label="Legend",
rankdir="LR",
color="white")
colors = list(color_map.values())
ic_label = ""
if show_ic: ic_label = "\nIC"
edge_types = set(map(lambda e: e[2]["value"], subgraph.edges(data=True)))
for k in filter(lambda k: k in edge_types,
reversed(edge_map.keys())): # count down
legend.add_node(
pydot.Node(label_map[k],
shape="underline",
color=edge_grey,
style=edge_map[k]))
# legend.add_node(pydot.Node(i, shape="point", color="white"))
# legend.add_edge(pydot.Edge(labels[i], i, label = labels[i], color = colors[i]))
legend.add_node(
pydot.Node("concept" + ic_label,
shape="ellipse",
color=normal_color,
style=concept_style))
legend.add_node(
pydot.Node("idea \n concept" + ic_label,
shape="ellipse",
color=concept_color,
style=concept_style))
G = pydot.Dot()
G.add_subgraph(legend)
G.write_png("pic/%s_legend.png" % name)
return G
def draw_legend(graph):
graphlegend = pydot.Cluster(graph_name="legend", label="Labels", fontsize="20", color="red",
fontcolor="blue", style="filled", fillcolor="white",fontname='Impact')
legend1 = pydot.Node('Processed', shape="plaintext",fontname='Impact')
graphlegend.add_node(legend1)
legend2 = pydot.Node("Killed ", shape="plaintext",fontname='Impact')
graphlegend.add_node(legend2)
legend3 = pydot.Node('Impossible', shape="plaintext",fontname='Impact')
graphlegend.add_node(legend3)
legend4 = pydot.Node('Goal', shape="plaintext",fontname='Impact')
graphlegend.add_node(legend4)
node1 = pydot.Node("1", style="filled", fillcolor="green", label="")
graphlegend.add_node(node1)
node2 = pydot.Node("2", style="filled", fillcolor="red", label="")
graphlegend.add_node(node2)
node3 = pydot.Node("3", style="filled", fillcolor="blue", label="")
graphlegend.add_node(node3)
node4 = pydot.Node("4", style="filled", fillcolor="gold", label="")
graphlegend.add_node(node4)
graph.add_subgraph(graphlegend)
graph.add_edge(pydot.Edge(legend1, legend2, style="invis"))
graph.add_edge(pydot.Edge(legend2, legend3, style="invis"))
graph.add_edge(pydot.Edge(legend3, legend4, style="invis"))
# graph.add_edge(pydot.Edge(legend4, legend5, style="invis"))
graph.add_edge(pydot.Edge(node1, node2, style="invis"))
graph.add_edge(pydot.Edge(node2, node3, style="invis"))
graph.add_edge(pydot.Edge(node3, node4, style="invis"))
def make_subgraph(path, parent_graph):
subgraph = pydot.Cluster(path,
label=split(path)[1],
style='rounded, filled',
fillcolor='#77777744')
parent_graph.add_subgraph(subgraph)
return subgraph
def index(graph):
graphlegend = pydot.Cluster(graph_name="legend",
label="Legend",
fontsize="20",
color="red",
fontcolor="blue",
style="filled",
fillcolor="white")
processed_node = pydot.Node('Processed node', shape="plaintext")
graphlegend.add_node(processed_node)
depth_lnode = pydot.Node("Depth limit reached", shape="plaintext")
graphlegend.add_node(depth_lnode)
gol_node = pydot.Node('Goal Node', shape="plaintext")
graphlegend.add_node(gol_node)
node1 = pydot.Node("1", style="filled", fillcolor="green", label="")
graphlegend.add_node(node1)
node2 = pydot.Node("2", style="filled", fillcolor="grey", label="")
graphlegend.add_node(node2)
node3 = pydot.Node("3", style="filled", fillcolor="blue", label="")
graphlegend.add_node(node3)
graph.add_subgraph(graphlegend)
graph.add_edge(pydot.Edge(processed_node, depth_lnode, style="invis"))
graph.add_edge(pydot.Edge(depth_lnode, gol_node, style="invis"))
graph.add_edge(pydot.Edge(node1, node2, style="invis"))
graph.add_edge(pydot.Edge(node2, node3, style="invis"))
def makeNode(tree, sg, node):
if node is not None:
code = node
if not code.isStandardCode():
nodecolor = "#4444FF"
elif code.annotation.descriptive:
nodecolor = "#FF3333"
elif code.codeparameters.selfparam is None:
nodecolor = '#BBBBBB'
else:
nodecolor = '#33FF33'
sg.add_node(
pydot.Node(str(id(node)),
label=dumputil.codeShortName(code),
shape='box',
style="filled",
fontsize=8,
fillcolor=nodecolor,
URL=links.codeRef(node, None)))
else:
sg.add_node(
pydot.Node(str(id(node)),
label="entry",
shape='point',
style="filled",
fontsize=8))
children = tree.get(node)
if children:
csg = pydot.Cluster(str(id(node)))
sg.add_subgraph(csg)
for child in children:
makeNode(tree, csg, child)
def draw_legend(graph):
graphlegend = pydot.Cluster(graph_name="legend",
label="Legend",
fontsize="20",
color="green",
fontcolor="blue",
style="filled",
fillcolor="white")
legend1 = pydot.Node('Visited node', shape="plaintext")
graphlegend.add_node(legend1)
legend2 = pydot.Node("Reached max height", shape="plaintext")
graphlegend.add_node(legend2)
legend3 = pydot.Node('Goal Node', shape="plaintext")
graphlegend.add_node(legend3)
node1 = pydot.Node("1", style="filled", fillcolor="yellow", label="")
graphlegend.add_node(node1)
node2 = pydot.Node("2", style="filled", fillcolor="red", label="")
graphlegend.add_node(node2)
node3 = pydot.Node("3", style="filled", fillcolor="green", label="")
graphlegend.add_node(node3)
graph.add_subgraph(graphlegend)
graph.add_edge(pydot.Edge(legend1, legend2, style="invis"))
graph.add_edge(pydot.Edge(legend2, legend3, style="invis"))
graph.add_edge(pydot.Edge(node1, node2, style="invis"))
graph.add_edge(pydot.Edge(node2, node3, style="invis"))
def generate_typesdiagram(self):
self.graficotypes = pydot.Dot(grap_name = "Diagrama de types",
graph_type = "digraph")
#dpi = 300 )
filetypes = self.__get_filetypes()
fileclusters = []
for filename in filetypes:
with open(filename) as searchfile:
unitname = self.__get_unit_name(searchfile)
print( unitname)
fileclusters.append(pydot.Cluster(unitname, label = unitname))
self.graficotypes.add_subgraph(fileclusters[-1])
for tipo in filetypes[filename]:
fileclusters[-1].add_node(pydot.Node(tipo))
for filename in filetypes:
for tipo in filetypes[filename]:
with open(filename) as searchfile:
typecode = self.get_type_code(tipo, searchfile)
print( "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!", typecode)
print( re.sub("\\\l","\n",typecode,re.ASCII))
used_types = self.get_used_types(re.sub("\\\l","\n",typecode,flags=re.ASCII))
for used_type in used_types:
self.graficotypes.add_edge(pydot.Edge(tipo, used_type))
self.graficotypes.write_png('graphs\\types_diagram.png'.format(time.strftime("%d%m%y%H%M")))
self.graficotypes.write_jpg('graphs\\types_diagram.jpg'.format(time.strftime("%d%m%y%H%M")))
self.graficotypes.write_pdf('graphs\\types_diagram.pdf'.format(time.strftime("%d%m%y%H%M")))
self.graficotypes.write_dot('graphs\\types_diagram.dot'.format(time.strftime("%d%m%y%H%M")))
def _bundle_to_dot(dot, bundle):
records = bundle.get_records()
relations = []
for rec in records:
if rec.is_element():
if isinstance(rec, ProvBundle):
count[2] = count[2] + 1
subdot = pydot.Cluster(graph_name='c%d' % count[2])
if use_labels:
subdot.set_label('"%s"' % str(rec.get_label()))
else:
subdot.set_label('"%s"' % str(rec.get_identifier()))
_bundle_to_dot(subdot, rec)
dot.add_subgraph(subdot)
else:
count[0] = count[0] + 1
node_id = 'n%d' % count[0]
if use_labels:
node_label = '"%s"' % str(rec.get_label())
else:
node_label = '"%s"' % str(rec.get_identifier())
style = DOT_PROV_STYLE[rec.get_type()]
node = pydot.Node(node_id, label=node_label, **style)
node_map[rec] = node
dot.add_node(node)
else:
relations.append(rec)
for rec in relations:
nodes = [
node for node in rec._attributes.values()
if node is not None and isinstance(node, ProvElement)
]
if len(nodes) < 2:
# Cannot draw this
pass
elif len(nodes) == 2 or not show_nary:
# binary relations
style = DOT_PROV_STYLE[rec.get_type()]
dot.add_edge(
pydot.Edge(node_map[nodes[0]], node_map[nodes[1]],
**style))
else:
# n-ary relations
style = DOT_PROV_STYLE[rec.get_type()]
# add a blank node
count[1] = count[1] + 1
bnode_id = 'b%d' % count[1]
bnode = pydot.Node(bnode_id, label='""', shape='point')
dot.add_node(bnode)
dot.add_edge(
pydot.Edge(node_map[nodes[0]],
bnode,
arrowhead='none',
**style))
style = dict(style)
del style['label']
for node in nodes[1:]:
dot.add_edge(pydot.Edge(bnode, node_map[node], **style))
style['color'] = 'gray'
def Gear(self, module):
if self.node_filter(module):
self.dot.node_map[module] = pydot.Node(module.name,
fontsize=18,
margin=0.01,
tooltip=module.name,
label=module.basename,
shape="doubleoctagon")
self.hier[-1].add_node(self.dot.node_map[module])
else:
self.dot.cluster_map[module] = pydot.Cluster(
graph_name=module.name,
label=module.basename,
tooltip=module.name,
fontsize=48,
fontcolor='blue',
labeljust='l',
overlap=False)
self.enter_hier(module)
super().HierNode(module)
self.exit_hier(module)
return True
def graph(self):
self.nodeNameSet = set([])
self.dimNameSet = set([])
for dotLink in self.theTraceLinks:
fromDimName = dotLink.fromObject()
self.dimNameSet.add(fromDimName)
fromName = dotLink.fromName()
if (fromName not in self.nodeNameSet):
self.buildNode(fromDimName, fromName)
self.nodeNameSet.add(fromName)
self.theNodeLookup[
fromName] = fromDimName + ' ' + dotLink.fromName()
toDimName = dotLink.toObject()
self.dimNameSet.add(toDimName)
toName = dotLink.toName()
if (toName not in self.nodeNameSet):
self.buildNode(toDimName, toName)
self.nodeNameSet.add(toName)
self.theNodeLookup[toName] = toDimName + ' ' + dotLink.toName()
dirType = 'none'
if (fromDimName == 'risk' and toDimName == 'vulnerability'):
dirType = 'forward'
edge = pydot.Edge(str(fromName), str(toName), dir=dirType)
self.theGraph.add_edge(edge)
if (self.isTagged == True):
tags = self.dbProxy.riskModelTags(self.theEnvironmentName)
if (len(tags) > 0):
for tag in tags:
cluster = pydot.Cluster(tag, label=tag)
for objt in tags[tag]:
cluster.add_node(pydot.Node(objt))
self.theGraph.add_subgraph(cluster)
return self.layout()
def visualize_graph(trgt, rules, outpath):
"""Draw a figure representing the dependency graph.
By default writes the graph to a file named the same as the calling
script.
"""
import pydot
root, graph = build_dep_graph(trgt, rules)
orders, newester_order_update = build_orders(root, graph)
dot = pydot.Dot(graph_name="Dependency",
graph_type='digraph',
labelloc='r',
rankdir="BT")
dot.set_node_defaults(shape='ellipse', fontsize=24)
for req in graph:
for preq in graph[req]:
dot.add_edge(pydot.Edge(preq.target, req.target))
for rank, rank_reqs in enumerate(reversed(orders), 1):
rank_plate = pydot.Cluster(graph_name=str(rank),
label="Order set {r}".format(r=rank))
for req in rank_reqs:
rank_plate.add_node(pydot.Node(req.target))
dot.add_subgraph(rank_plate)
return dot.write_png(outpath)
def _draw_subgraph(progenitor: pydot.Dot, diagram: Union[pydot.Dot,
pydot.Cluster],
label_last_seen: DefaultDict[str,
str], subgraph_name: str,
subgraph_ops: List[Union[Op, Trace, Any]]) -> None:
"""Draw a subgraph of ops into an existing `diagram`.
Args:
progenitor: The very top level diagram onto which Edges should be written.
diagram: The diagram into which to add new Nodes.
label_last_seen: A mapping of {data_dict_key: node_id} indicating the last node which generated the key.
subgraph_name: The name to be associated with this subgraph.
subgraph_ops: The ops to be wrapped in this subgraph.
"""
subgraph = pydot.Cluster(style='dashed',
graph_name=subgraph_name,
color='black')
subgraph.set('label', subgraph_name)
subgraph.set('labeljust', 'l')
for idx, op in enumerate(subgraph_ops):
node_id = str(id(op))
Traceability._add_node(progenitor, subgraph, op, label_last_seen)
if isinstance(op, Trace) and idx > 0:
# Invisibly connect traces in order so that they aren't all just squashed horizontally into the image
progenitor.add_edge(
pydot.Edge(src=str(id(subgraph_ops[idx - 1])),
dst=node_id,
style='invis'))
diagram.add_subgraph(subgraph)
def add_subgraph_to_graph(self,
graph,
subgraphlabel,
rank='same',
simplify=True,
rankdir='TB',
ranksep=0.2,
compound=True,
color=None,
shape='box',
style='bold'):
"""
creates a cluster subgraph item for this factory, adds it to the graph.
cluster name can vary from label but must always be same for the same node label.
Most layouters require cluster names to start with cluster.
"""
if subgraphlabel is None or subgraphlabel == '':
raise ValueError('Empty subgraph label')
g = pydot.Cluster(self.escape_name(subgraphlabel),
rank=rank,
rankdir=rankdir,
simplify=simplify)
if 'set_style' in g.__dict__:
g.set_style(style)
if 'set_shape' in g.__dict__:
g.set_shape(shape)
if LooseVersion(pydot.__version__) > LooseVersion('1.0.10'):
g.set_compound(compound)
g.set_ranksep(ranksep)
g.set_label(subgraphlabel)
if 'set_color' in g.__dict__:
if color is not None:
g.set_color(color)
graph.add_subgraph(g)
return g
def __missing__(self, path):
subgraph = pydot.Cluster(sep.join(path),
label=stub(path),
style='rounded, filled',
fillcolor='#77777744')
self[parent(path)].add_subgraph(subgraph)
return subgraph
def createMachine(self):
#creates the initial version of the state machine
self.graph = pydot.Dot(graph_type='digraph', rankdir="LR")
graphlegend = pydot.Cluster(graph_name="NTSG",
label="NTSG",
rankdir="TB")
self.node = []
for i in range(self.numNodes):
#self.node.append(pydot.Node("Node %d" % (i) + " : " + messageTypes[i].name, rank="same"))
self.node.append(pydot.Node("Node %d" % (i), rank="same"))
self.graph.add_node(self.node[i])
for i in range(self.numNodes):
if (i < (self.numNodes - 1)):
#draw the initial edges
self.graph.add_edge(pydot.Edge(self.node[i], self.node[i + 1]))
#create a transition and append it to the list
self.transitions.append(transition().createTransition(
i, (i + 1)))
self.graph.write_png('stateMachine.png')
def add_cluster(self,
name,
label=None,
rank='same',
rankdir='TB',
simplify=True,
color=None,
shape='circle',
compound=True,
style='bold',
ranksep=0.2,
orientation='portrait'):
name = escape_text(name)
c = pydot.Cluster(escape_text(name),
rank=rank,
rankdir=rankdir,
simplify=simplify)
if 'set_shape' in c.__dict__:
c.set_shape(shape)
if 'set_style' in c.__dict__:
c.set_style(style)
if 'set_color' in c.__dict__:
c.set_color(color)
c.set_compound(compound)
c.set_ranksep(ranksep)
c.set_label(label or name)
self.graph.add_subgraph(c)
self.subgraphs[name] = GraphWrapper(graph=c)
# print(c.get_name())
return self.subgraphs[name]
def add_subgraph(_as, **kwargs):
if _as not in subgraphs:
subgraphs[_as] = pydot.Cluster("cluster_%s" % _as,
label="",
**kwargs)
graph.add_subgraph(subgraphs[_as])
return subgraphs[_as]
