def init_graph():
"init the graph and image panel"
dot = Digraph()
dot.name = "topology"
dot.format = "gif"
dot.filename = "zigbee_topology"
return dot
def draw( self, vec, contentMatrix, fig_coment,K = 0, filter_lonelyRoot = False, filter_noRequest = True):
self.find_lonely(vec)
# dot = Digraph(comment=fig_coment, engine='dot')
# dot = Digraph(comment=fig_coment, engine='neato')
dot = Digraph(comment=fig_coment, engine='fdp')
# dot = Digraph(comment=fig_coment, engine='twopi')
dot.format = 'svg'
# dot.body.extend(['rankdir=LR']) # set vertical layout
if K >0:
time_consuming = self.most_timeConsuming(contentMatrix['wait_interval'],K)
else:
time_consuming = []
# dot.body.append('center=ture')
# dot.node_attr.update(color='lightblue2', style='filled',width='0.04',height='0.04')
for i in range(0,len(vec)):
if (filter_lonelyRoot and (i in self.lonely)) or vec[i]<0:
continue
if i in time_consuming:
if contentMatrix['wait_interval'][i] != -1:
dot.node(str(i+1),"("+str(i+1)+")\n"+contentMatrix['mimeType'][i].split(';')[0].split('/')[-1]+':'+str(contentMatrix['wait_interval'][i]),color='tomato2', style='filled')
elif not filter_noRequest:
dot.node(str(i+1),"("+str(i+1)+")\n"+"no request", style='filled')
else:
if contentMatrix['wait_interval'][i] != -1:
dot.node(str(i+1),"("+str(i+1)+")\n"+contentMatrix['mimeType'][i].split(';')[0].split('/')[-1]+':'+str(contentMatrix['wait_interval'][i]),color='lightblue2', style='filled')
elif not filter_noRequest:
dot.node(str(i+1),"("+str(i+1)+")\n"+"no request", style='filled')
if vec[i] != 0 and ((not filter_noRequest) or contentMatrix['wait_interval'][i] != -1):
dot.edge(str(vec[i]), str(i+1))#,constraint='false')
dot.render(fig_coment+'_treeplot.dot', view=True)
return dot
def generate_graph(self, rule_links, out_file):
graph_label = 'Rule based visualizer'
graph_attr = {
'rankdir': 'TD',
'labelloc': 't',
'fontsize': '15',
'label': graph_label
}
node_attr = {}
dot = Digraph(comment='Rule based links visualization',
node_attr=node_attr, graph_attr=graph_attr, format='png')
nodes = set()
for _, rule_link in rule_links:
print(rule_link._source_action_ref)
if rule_link._source_action_ref not in nodes:
nodes.add(rule_link._source_action_ref)
dot.node(rule_link._source_action_ref, rule_link._source_action_ref)
if rule_link._dest_action_ref not in nodes:
nodes.add(rule_link._dest_action_ref)
dot.node(rule_link._dest_action_ref, rule_link._dest_action_ref)
dot.edge(rule_link._source_action_ref, rule_link._dest_action_ref, constraint='true',
label=rule_link._rule_ref)
output_path = os.path.join(os.getcwd(), out_file)
dot.format = 'png'
dot.render(output_path)
def draw(FA, adj, output):
newAlpha = list(FA[1])
if newAlpha[-1] == EPS:
newAlpha.pop();
sigma = ', '.join(newAlpha)
gr = Digraph();
gr.engine = 'dot'
gr.format = 'pdf'
gr.attr('node', style = 'invis');
gr.node('myStarting');
gr.attr('node', style = '', shape = 'doublecircle');
for u in FA[-1]:
gr.node(str(u));
gr.attr('node', shape = 'circle');
for u in FA[0]:
if u not in FA[-1]:
gr.node(str(u))
gr.edge('myStarting', str(FA[2]), 'Start');
for u, v in adj.keys():
if adj[u, v] == sigma:
gr.edge(str(u), str(v), 'Sigma')
else:
gr.edge(str(u), str(v), adj[u, v])
gr.render(output, view = True);
def dumpgraph(request,descl, comment,rankdir="RL", student=None,ALL=True):
dot = Digraph(comment=comment)
dot.format='svg'
dot.graph_attr['rankdir'] = rankdir
if student != None:
student = get_object_or_404(Student,student_id=student)
s=set()
for l in descl:
s.add(l.ascendant)
s.add(l.descendant)
for x in s:
if student != None and student.knowsConcept(x.name) :
cc = student.conceptlevel(x.name)
l= ['red','green','orange','yellow']
cc=l[min(cc,len(l)-1)]
dot.node(x.name,URL=x.makeUrl(),color=cc,style="filled",shape="box")
else:
if ALL :
dot.node(x.name,URL=x.makeUrl(),color="red",style="filled",shape="box")
for l in descl:
if ALL:
dot.edge(l.descendant.name,l.ascendant.name)
else:
if student != None and student.knowsConcept(l.descendant.name) and student.knowsConcept(l.ascendant.name):
dot.edge(l.descendant.name,l.ascendant.name)
dot.render('concept/templates/concept/graph')
def generate_graph(self, graph: Digraph, sub_graphs: tuple, name):
graph.format = self.img_format
graph.directory = self.directory
for sub_graph in sub_graphs:
graph.subgraph(sub_graph)
graph.render('{} {}'.format(self.file_prefix, name), None, False)
print('Class diagram {} written.'.format(name))
def render_block_graph(qmp, filename, format='png'):
'''
Render graph in text (dot) representation into "@filename" and
representation in @format into "@filename.@format"
'''
bds_nodes = qmp.command('query-named-block-nodes')
bds_nodes = {n['node-name']: n for n in bds_nodes}
job_nodes = qmp.command('query-block-jobs')
job_nodes = {n['device']: n for n in job_nodes}
block_graph = qmp.command('x-debug-query-block-graph')
graph = Digraph(comment='Block Nodes Graph')
graph.format = format
graph.node('permission symbols:\l'
' w - Write\l'
' r - consistent-Read\l'
' u - write - Unchanged\l'
' g - Graph-mod\l'
' s - reSize\l'
'edge label scheme:\l'
' <child type>\l'
' <perm>\l'
' <shared_perm>\l', shape='none')
for n in block_graph['nodes']:
if n['type'] == 'block-driver':
info = bds_nodes[n['name']]
label = n['name'] + ' [' + info['drv'] + ']'
if info['drv'] == 'file':
label += '\n' + os.path.basename(info['file'])
shape = 'ellipse'
elif n['type'] == 'block-job':
info = job_nodes[n['name']]
label = info['type'] + ' job (' + n['name'] + ')'
shape = 'box'
else:
assert n['type'] == 'block-backend'
label = n['name'] if n['name'] else 'unnamed blk'
shape = 'box'
graph.node(str(n['id']), label, shape=shape)
for e in block_graph['edges']:
label = '%s\l%s\l%s\l' % (e['name'], perm(e['perm']),
perm(e['shared-perm']))
graph.edge(str(e['parent']), str(e['child']), label=label)
graph.render(filename)
def draw(self, name, output_dir):
# Cria grafo direcionado e define o estilo padrao dos nos
dot = Digraph(name = name)
dot.graph_attr['rankdir'] = 'LR'
dot.graph_attr['pad'] = '0.5,0.5'
dot.node_attr['shape'] = 'circle'
dot.node_attr['style'] = 'filled'
dot.node_attr['fillcolor'] = 'aquamarine4'
dot.format = 'png'
# Obtem os rotulos dos estados e os coloca em ordem alfabetica
states = list(self.states.keys())
states.sort()
# Adicionana cada estado como um no do grafo
for state in states:
# Estilo do estado inicial
if state == self.initial_state:
# Estilo diferenciado caso o estado inicial seja tambem final
if state in self.marked_states:
dot.node(state, shape = 'doublecircle', fillcolor = 'cornflowerblue', color = 'cornflowerblue')
else:
dot.node(state, fillcolor = 'cornflowerblue')
elif state in self.marked_states:
# Estili diferenciado para os estados finais
dot.node(state, shape = 'doublecircle', fillcolor = 'brown1', color = 'brown1')
else:
# Adiciona estados com o estilo padrao
dot.node(state)
# Adiciona no que aponta para o estado inicial
dot.node('', shape = 'point', fillcolor = '#000000')
dot.edge('', self.initial_state)
# Adciona os eventos
for state_label, state in self.states.items():
for event, edges in state.edges.items():
for edge in edges:
dot.edge(state_label, edge, label = event)
# Verifica se o diretoria output existe, caso nao exista ele e criado
if not os.path.exists(output_dir) or not os.path.isdir(output_dir):
os.mkdir(output_dir)
# Renderiza a imagem do automato
dot.render(output_dir + os.sep + name)
# Remove os arquivos desnecessarios apos renderizacao
os.remove(output_dir + os.sep + name)
def __init__(self, tree, name='Arvore_QueensPuzzle'):
"""Contrutor da classe DrawTree"""
super(DrawTree, self).__init__()
# Cópia da árvore
self.tree = copy.deepcopy(tree)
global dot
# Cria grafo direcionado
dot = Digraph(name = name)
dot.format = 'png'
# Desenha árvore
self.draw(self.tree)
# Visualiza a imagem da árvore
dot.view()
def display_tree(root,**kwargs):
max_depth = 5
dot = Digraph(comment='MCTS Tree')
fringe = [(None,0,root)]
while fringe:
(parent_hash,d,child) = fringe.pop()
child_str = str(child)
child_hash = str(hash(child))
if child.is_leaf():
dot.attr('node',shape='box',style='')
else:
dot.attr('node',shape='ellipse',style='')
dot.node(child_hash,child_str)
if parent_hash:
label = str(child.state)
dot.edge(parent_hash,
child_hash,
label=label)
# Add new nodes
for a_id in child.children:
if d < max_depth:
dot.attr('node',shape='diamond',style='filled')
child_aid_hash = child_hash + str(a_id)
dot.node(child_aid_hash,'')
else:
dot.attr('node',shape='box',style='filled')
child_aid_hash = child_hash + str(a_id)
dot.node(child_aid_hash,'...')
label = '{0},{1:0.2f},{2}'.format(a_id,
child.get_ucb(a_id),
child.costs[a_id])
dot.edge(child_hash,
child_aid_hash,
label=label)
if d < max_depth:
for gc in child.children[a_id]:
fringe.append((child_aid_hash,d+1,gc))
dot.format='png'
dot.render('data/test.gv')
img = mpimg.imread('data/test.gv.png')
plt.imshow(img)
plt.title(kwargs.get('title',''))
plt.show()
def render_graph(nodes, filename):
dot = Digraph(name='windbg_graph', node_attr={'shape': 'box', 'fontname' : 'Lucida Console'}, graph_attr={'splines':'polyline'})
for anode in nodes:
if(anode.has_color()):
dot.node(anode.get_nodeName(),anode.get_dotformat_label(), _attributes={'style':'filled', 'fillcolor':'gray'})
else:
dot.node(anode.get_nodeName(),anode.get_dotformat_label())
connections = anode.get_connections()
for connection in connections:
dot.edge(anode.get_nodeName(),connection)
#print(dot.source)
dot.format = outputformat
graph_file = dot.render(filename, view=False)
os.unlink(filename)
return graph_file
def graph(self):
dot = Digraph(comment='Lista Canciones')
dot.format = 'png'
actual = self.head
i = 0
while actual:
dot.node(str(i), actual.getNombre())
actual = actual.getSiguiente()
i += 1
if actual == self.head:
break
dot.edge(str(i - 1), str(i), constraint='false')
dot.edge(str(i), str(i - 1), constraint='false')
dot.edge(str(i - 1), str(0), constraint='false')
dot.edge(str(0), str(i - 1), constraint='false')
dot.render(filename="listaCanciones",
directory="C:\\Graphs\\",
view=True,
cleanup=True)
def render_graph(system, user_query):
dot = Digraph(
node_attr=dict(shape='box', style='rounded, filled'),
graph_attr=dict(splines='ortho'),
)
# Nodes
render_nodes(dot, system, '#deebff')
render_nodes(dot, user_query, '#ffebcc')
# Edges
render_edges(dot, system)
render_edges(dot, user_query)
file = "chatbot-design"
file_format = 'svg'
dot.format = file_format
dot.render(file, cleanup=True, view=False)
return f"{file}.{file_format}"
def display_history_png(instance_id):
instance = InstanceStory.query.get_or_404(instance_id)
if not is_obj_of_current_user(instance):
return abort(403)
histories = instance.history.order_by(HistoryInstance.timestamp.asc()).all()
res = Response()
g = Digraph(instance.story.name)
step_ids = []
for history in histories:
if history.from_step_id and not history.from_step_id in step_ids:
step_ids.append(history.from_step_id)
if history.to_step_id and not history.to_step_id in step_ids:
step_ids.append(history.to_step_id)
steps_tmp = Step.query.filter(Step.id.in_(step_ids))
steps = {}
for step in steps_tmp:
steps[step.id] = step
for history in histories:
if history.from_step_id and not history.from_step_id in steps:
step = Step.query.get(history.from_step_id)
steps[history.from_step_id] = step
if history.to_step_id and not history.to_step_id in steps:
step = Step.query.get(history.to_step_id)
steps[history.to_step_id] = step
for step_id in steps:
step = steps[step_id]
if step.final:
g.node('step_%d' % step.id, label=step.name, color="lightblue2", style="filled")
else:
g.node('step_%d' % step.id, label=step.name)
index = 1
for history in histories:
if history.from_step_id:
g.edge('step_%d' % history.from_step_id, 'step_%d' % history.to_step_id, label = "%d. %s" % (index, history.choice_text))
index += 1
g.format = 'png'
res.content_type = "image/png"
res.data = g.pipe()
return res
def visualize(ts, parameters=None):
if parameters is None:
parameters = {}
image_format = parameters["format"] if "format" in parameters else "png"
show_labels = parameters[
"show_labels"] if "show_labels" in parameters else True
show_names = parameters[
"show_names"] if "show_names" in parameters else True
force_names = parameters[
"force_names"] if "force_names" in parameters else None
if force_names:
nts = copy(ts)
for index, state in enumerate(nts.states):
state.name = state.name + " (%.2f)" % (force_names[state])
ts = nts
filename = tempfile.NamedTemporaryFile(suffix='.gv')
viz = Digraph(ts.name, filename=filename.name, engine='dot')
# states
viz.attr('node')
for s in ts.states:
if show_names:
viz.node(str(s.name))
else:
viz.node(str(s.name), "")
# arcs
for t in ts.transitions:
if show_labels:
viz.edge(str(t.from_state.name),
str(t.to_state.name),
label=t.name)
else:
viz.edge(str(t.from_state.name), str(t.to_state.name))
viz.attr(overlap='false')
viz.attr(fontsize='11')
viz.format = image_format
return viz
def visualize(ts, parameters=None, value=None, aggregation_measure=None):
if parameters is None:
parameters = {}
image_format = parameters["format"] if "format" in parameters else "png"
show_labels = parameters[
"show_labels"] if "show_labels" in parameters else True
show_names = parameters[
"show_names"] if "show_names" in parameters else True
show_value = False if aggregation_measure is None else True
filename = tempfile.NamedTemporaryFile(suffix='.gv')
viz = Digraph(ts.name, filename=filename.name, engine='dot')
# states
viz.attr('node')
for s in ts.states:
if show_names:
viz.node(str(s.name))
else:
viz.node(str(s.name), "")
# arcs
for t in ts.transitions:
if show_value:
aggr_stat = aggregate_stats(t.data[value], aggregation_measure)
#aggr_stat_hr = human_readable_stat(aggr_stat)
viz.edge(str(t.from_state.name),
str(t.to_state.name),
label=str(aggr_stat))
elif show_labels:
viz.edge(str(t.from_state.name),
str(t.to_state.name),
label=t.name)
else:
viz.edge(str(t.from_state.name), str(t.to_state.name))
viz.attr(overlap='false')
viz.attr(fontsize='11')
viz.format = image_format
return viz
def render_current_generation(self, folder_name: str):
"""
this function render the current generation in PNG format with some extra information
:param folder_name:
:return:
"""
g = Digraph()
g.format = 'png'
g.directory = folder_name + "/Generation " + str(self.generation)
counter = 1
for tree in self.population:
g.clear()
info = '"00_comment_00" [label="G : {0}\nF : {1}\nD : {2}\nW : {3}\nn : {4}" , shape="box" , color="white"]'.format(
self.generation, tree.fitness, tree.depth, tree.width,
tree.number_of_nodes_in_tree)
g.body.append(info)
g.body.append(tree.print_graph())
g.render("Individual {0}".format(counter))
counter += 1
def graficar(self):
self.text = ""
g = Digraph('G', filename='graficaListaUsuarios.gv')
g.body.append('rankdir=LR')
g.attr('node', shape='box', color='blue')
aux = self.first
if aux == None:
print "Lista vacia"
g.body.append('"Lista Vacia"')
else:
while True:
g.body.append('"'+str(aux.nombre)+str(aux.pasword)+'"'+' [label="'+str(aux.nombre)+'\\n'+str(aux.pasword)+'"];\n')
g.edge(str(aux.nombre)+str(aux.pasword), str(aux.next.nombre)+str(aux.next.pasword))
g.body.append('[dir=both arrowhead=halfopen color=darkgreen]')
aux = aux.next
if (aux == self.last.next):
break
g.body.append('label = "Lista Doblemente Enlazada de Usuarios"; \n')
g.format = 'png'
g.render('test-output/Lista-Usuario/graficaListaUsuarios.gv', view=True)
def graph():
letters_to_show = 6
wit = valid_wit(os.getcwd())
if not wit:
return
references_path = os.path.join(wit, "references.txt")
head = get_head(references_path)
parent = get_parent(wit=wit, commit_id=head)
commit_graph = Digraph()
commit_graph.node('HEAD', head[:letters_to_show], shape='circle')
current = 'HEAD'
while parent != 'None':
commit_graph.node(parent, parent[:letters_to_show], shape='circle')
commit_graph.edge(current, parent, constraint='false')
current = parent
parent = get_parent(wit=wit, commit_id=parent)
commit_graph.format = 'png'
commit_graph.render('graph.gv', view=True, directory=wit, cleanup=True)
def dot(layers, edges):
g = Digraph(
"dag",
graph_attr={"dpi": str(600)},
node_attr={
"fontname": "Courier New",
"shape": "box"
},
edge_attr={"fontname": "Courier New"},
)
g.format = "png"
for layer, width in layers.items():
g.node(layer, label="{}\n{}".format(layer, width))
for parents, children in edges:
for parent, child in itertools.product(parents, children):
g.edge(parent, child)
return g
def generate_bn_image(bn):
"""
Auxiliary function for generating the image of a BN, as model
methods are not available in migrations.
"""
dot = Digraph(comment=bn.name)
nodes = bn.nodes.all()
for node in nodes:
dot.node(name=node.name, label=node.name)
edges = bn.edges.all()
for edge in edges:
dot.edge(str(edge.parent.name),
str(edge.child.name))
dot.format = "png"
contentfile = ContentFile(dot.pipe())
image_name = "{0}/{1}".format(
os.path.join("django_ai", "bayesian_networks"),
bn.name + ".png")
bn.image.save(image_name, contentfile)
bn.save()
def genDag(name, tree):
dot = Digraph(comment='Dag')
i = 0
for triangle in tree:
addr = triangle['addr']
valid = triangle["valid"]
dot.node(addr,'{}({})'.format(addr, valid))
i += 1
for triangle in tree:
addr = triangle['addr']
children = triangle['children']
for c in children:
if None != c:
dot.edge(addr, c)
dot.format = 'png'
dot.render(name)
return name
def doit_each(namelist, dotoption):
dottree = Digraph("caus")
dottree.graph_attr["rankdir"] = "TB"
dottree.graph_attr["concentrate"] = str(dotoption["concentrate"])+";"
for filename in namelist:
basename, ext = os.path.splitext(filename)
print("doit_each, basename", basename)
with open(filename) as f:
dataall = yaml.safe_load(f)
fdtree = FDTree(basename, dottree, dotoption=dotoption)
dottree = fdtree.apply(dataall, basename=basename, make_png=False)
dottree.format = "png"
dottree.render(view=False)
print("done")
def plot_node_structure_as_directed_graph(node_structure,
file_prefix='',
drawing_name='tmp_.png',
popup=True,
node_dic=None):
pure_leaves, admix_leaves, pure_coalescence, admix_coalescence, root, edges, inner_node_colors = node_structure_to_networkx(
node_structure, node_dic)
print pure_leaves, admix_leaves, pure_coalescence, admix_coalescence, root, edges, inner_node_colors
filename, image_format = drawing_name.split('.')
G = Digraph('G', filename=filename)
leaves_graph = Digraph('l')
leaves_graph.node_attr.update(style='filled', color='cadetblue1')
for leaf in pure_leaves:
leaves_graph.node(leaf)
aleaves_graph = Digraph('l')
aleaves_graph.node_attr.update(style='filled', color='slateblue1')
for leaf in admix_leaves:
aleaves_graph.node(leaf)
admixture_graph = Digraph()
admixture_graph.node_attr.update(style='filled',
fillcolor='coral1',
shape='box')
for adm_n in admix_coalescence:
admixture_graph.node(adm_n, fillcolor=inner_node_colors[adm_n])
coalescence_graph = Digraph()
coalescence_graph.node_attr.update(style='filled', fillcolor='greenyellow')
for cn in pure_coalescence:
coalescence_graph.node(cn, fillcolor=inner_node_colors[cn])
G.subgraph(leaves_graph)
G.subgraph(aleaves_graph)
G.subgraph(admixture_graph)
G.subgraph(coalescence_graph)
G.node('r', shape='egg', color='black', style='filled', fontcolor='white')
G.edges(edges)
G.format = image_format
G.render(view=popup)
def resource_tracker_graph(request):
dot = Digraph(comment='Graph')
dot.attr(bgcolor=COLORS["transparent"])
dot.name = 'Resource Tracker Graph'
dot.attr('node', shape='plaintext')
tags = Tag.objects.all()
resource_graph_filtered = GraphFilter(request.GET, queryset=tags)
display_graph = False
if "tag" in request.GET:
tag_list = request.GET.getlist("tag")
resource_pool_queryset = ResourcePool.objects.filter(tags__name__in=tag_list)
resource_group_queryset = ResourceGroup.objects.filter(tags__name__in=tag_list)
else:
resource_pool_queryset = ResourcePool.objects.all()
resource_group_queryset = ResourceGroup.objects.all()
for resource_pool in resource_pool_queryset:
dot.node(f'{get_graph_name(resource_pool)}', label=create_resource_pool_svg(resource_pool))
display_graph = True
for resource_group in resource_group_queryset:
display_graph = True
dot.node(f'{get_graph_name(resource_group)}', label=create_resource_group_svg(resource_group))
for attribute in resource_group.attribute_definitions.filter():
rg = f'{get_graph_name(resource_group)}:{attribute.name}'
if attribute.consume_from:
dot.edge(f'{get_graph_name(attribute.consume_from.resource_pool)}:{attribute.consume_from.name}', rg,
color=COLORS['provider'])
if attribute.produce_for:
dot.edge(rg, f'{get_graph_name(attribute.produce_for.resource_pool)}:{attribute.produce_for.name}',
color=COLORS['consumer'])
dot.format = 'svg'
svg = mark_safe(dot.pipe().decode('utf-8'))
return render(request, 'resource_tracking/graph/resource-tracker-graph.html',
context={'svg': svg,
'display_graph': display_graph,
'resource_graph': resource_graph_filtered})
def make_sub_graph(self, function_object):
all_calls_address = []
all_funcs = []
all_function_address = []
sub_graph = Digraph(
"cluster_" + function_object.get_extra_string(),
graph_attr={"label": function_object.get_extra_string()})
sub_graph.format = 'svg'
function_object.mark_visited()
for f in function_object.get_sub_functions():
if not f.has_visited(
) and f.get_sub_function_type() != eSubFunctionType.Unknown:
sub_graph.subgraph(self.make_sub_graph(f))
else:
all_function_address.append(f.get_start_address())
all_funcs.append(f)
all_calls_address.extend(f.get_calls())
for n in all_function_address:
# string = "{:4X}".format(n)
string = Regenerator.Regenerator_getLabelForAddr(n)
sub_graph.node(string)
for address in all_calls_address:
# string = "{:4X}".format(address)
string = Regenerator.Regenerator_getLabelForAddr(address)
sub_graph.node(string, shape='cds')
for f in all_funcs:
for jump in f.get_jumps():
# stringA = "{:4X}".format(f.getStartAddr())
string_a = Regenerator.Regenerator_getLabelForAddr(
f.get_start_address())
# stringB = "{:4X}".format(jump)
string_b = Regenerator.Regenerator_getLabelForAddr(jump)
sub_graph.edge(string_a, string_b)
for call in f.get_calls():
# stringA = "{:4X}".format(f.getStartAddr())
string_a = Regenerator.Regenerator_getLabelForAddr(
f.get_start_address())
# stringB = "{:4X}".format(call)
string_b = Regenerator.Regenerator_getLabelForAddr(call)
sub_graph.edge(string_a, string_b, color='red')
return sub_graph
def generate_png(story_id):
story = Story.query.get_or_404(story_id)
res = Response()
g = Digraph(story.name)
for step in story.steps:
if step.final:
g.node('step_%d' % step.id, label=step.name, color="lightblue2", style="filled")
else:
g.node('step_%d' % step.id, label=step.name)
if step.first_choice_step_id:
g.edge('step_%d' % step.id, 'step_%d' % step.first_choice_step_id, label = step.first_choice)
if step.second_choice_step_id:
g.edge('step_%d' % step.id, 'step_%d' % step.second_choice_step_id, label = step.second_choice)
if str(request.url_rule).endswith('dot'):
res.content_type = "text/plain"
res.data = g.source
elif str(request.url_rule).endswith('png'):
g.format = 'png'
res.content_type = 'image/png'
res.data = g.pipe()
return res
def graph(self):
dot = Digraph(comment='Cola Circular de Canciones')
dot.format = 'png'
actual = self.primero
if self.size == 1:
dot.node(
str(0), 'Artista - ' + actual.getDatos().getArtista() +
'\nCancion: ' + actual.getDatos().getCancion())
dot.edge(str(0), str(0), constraint='false')
elif self.size == 2:
i = 0
while actual:
dot.node(
str(i), 'Artista - ' + actual.getDatos().getArtista() +
'\nCancion: ' + actual.getDatos().getCancion())
actual = actual.getSiguiente()
i += 1
if actual == self.primero:
break
dot.edge(str(i), str(i - 1), constraint='false')
dot.edge(str(0), str(i - 1), constraint='false')
elif self.size > 2:
i = 0
while actual:
dot.node(
str(i), 'Artista - ' + actual.getDatos().getArtista() +
'\nCancion: ' + actual.getDatos().getCancion())
actual = actual.getSiguiente()
i += 1
if actual == self.primero:
break
dot.edge(str(i - 1), str(i), constraint='false')
dot.edge(str(i), str(i - 1), constraint='false')
dot.edge(str(i - 1), str(0), constraint='false')
dot.edge(str(0), str(i - 1), constraint='false')
dot.render(filename="colaCanciones",
directory="C:\\Graphs\\",
view=True,
cleanup=True)
print dot
def makeGraphviz(self):
"""générer l'objet graphviz
:rtype: None
"""
dot = Digraph(comment="graphe MPM",
node_attr={"shape":"plaintext"})
dot.attr("graph", rankdir="LR")
dot.format = "png"
# création des sous-graphes par niveau
NIVtmp = list(set(self.niveaux.values()))
NIV = sorted(NIVtmp)
for N in NIV:
with dot.subgraph(name=f"cluster_{N}",
node_attr={'rank': 'same'}) as c:
c.attr(style="invis") # désactivation du cadre de cluster
if self.show_level:
c.node(f"niv{N}")
for k, n in self.sommets.items(): # key, noeud
if self.niveaux[k] == N:
c.node(str(k), f"<{n.noeud}>")
# la str html doit être encadrée de <>
# branchement du nœud de départ:
dot.node("debut", self.titre_debut, shape='ellipse')
for k, n in self.sommets.items(): # key, noeud
if self.niveaux[k] == NIV[0]:
dot.edge("debut", k)
# création des autres arcs, pondérés
for k, L in self.successeurs.items():
for i in list(L):
dot.edge(k, i, label=str(self.ponderation[k]),
tailport="here", headport="here") # from to
# création des liaisons de titres de niveaux
if self.show_level:
for N in NIV[:-1]:
dot.edge(f"niv{N}", f"niv{N+1}", style='invis')
self.gv = dot
def generate_class_diagram(self, output_file_name=None):
if output_file_name is None:
output_file_name = self.output_class_diagram
try:
dot = Digraph(comment='UML Class Diagram')
dot.node_attr['shape'] = "record"
dot.format = "dot"
if len(self.components) > 0:
for comp in self.components:
attributes = self._build_attributes_string(
comp.get_attributes())
functions = ""
for funct in comp.get_functions():
functions += funct + "\\n"
record = "{"
record += "{name} | {attribs} |{functs}".format(
name=comp.get_name(),
attribs=attributes,
functs=functions)
record += "}"
dot.node(comp.get_name(), record)
for parent in comp.get_parents():
dot.edge(parent.get_name(), comp.get_name())
dot.edge_attr.update(dir="back")
dot.edge_attr.update(arrowtail='empty')
dot.render(output_file_name, view=False)
self.write_dot_to_png(dot_file=output_file_name)
if path.exists(output_file_name):
remove(output_file_name)
if path.exists(output_file_name + ".dot"):
remove(output_file_name + ".dot")
else:
print("no components were found")
except ExecutableNotFound:
print(
"Graphviz executable not found, please check it is properly installed."
)
except (CalledProcessError, RuntimeError) as err:
print("An unexpected error occurred")
print(err)
def draw_fa(fa, final, start, file_name="my_first"):
dot = Digraph('finite_state_machine')
dot.attr(rankdir='LR', size='8,5')
dot.format = 'png'
edges_ls = []
for n in fa:
if n in final:
dot.attr('node', shape='doublecircle')
dot.node(str(n))
elif n == start:
dot.attr('node', shape="Mcircle")
dot.node(str(n))
else:
dot.attr('node', shape="ellipse")
dot.node(str(n))
for node in fa:
dot.node(str(node), str(node))
if len(fa[node]) == 0:
pass
else:
for symbol in fa[node]:
try:
for s in fa[node][symbol]:
edges_ls.append([str(node), str(s), str(symbol)])
except:
edges_ls.append(
[str(node),
str(fa[node][symbol]),
str(symbol)])
for e in edges_ls:
dot.edge(e[0], e[1], label=e[2])
dot.view()
isSave = input("Do you want to save this[Y/N] ")
if isSave == 'Y':
f_name = input("Enter the file name to save the nfa in png ")
dot.render('output/' + f_name, view=True)
print("File saved at output/" + f_name + '.png')
def graph_by_epics(self) -> None:
output = self.config['output']['epics']
graph_file = output['graph']
logger.info(f"generating {graph_file}")
graph = Digraph(comment = f"Generated on {self.config['generated']}", graph_attr = {'rankdir': 'LR', 'splines': 'ortho'}, node_attr = {'shape': 'none'})
for epic in self.jira.sorted_by_key(self.jira.epics.values()):
self.add_node(graph, epic)
for story in self.jira.sorted_by_key(epic.stories):
self.add_node(graph, story)
self.add_edge(graph, epic, story)
for risk in self.jira.sorted_by_key(story.risks):
self.add_node(graph, risk)
self.add_edge(graph, story, risk)
for test in self.jira.sorted_by_key(story.tests):
self.add_node(graph, test)
self.add_edge(graph, story, test)
graph.engine = output['engine']
graph.format = output['format']
graph.render(filename = graph_file, cleanup = False, view = False)
def graph(self):
dot = Digraph(comment='chem', engine='neato')
label = ['OUT LEFT', 'OUT RIGHT', 'FOOD', 'WATER']
for i, chem in enumerate(self.controller.chemicals):
atts = { 'fontsize': '10'}
if i < len(label):
dot.node(chem.formula, shape='rectangle', fillcolor='gold', style='filled', label=f'<<b>{label[i]}</b><br/>{chem.formula}>', **atts)
else:
dot.node(chem.formula, shape='rectangle', label=f'<{chem.formula}>', **atts)
for rxn in self.controller.reactions:
atts = {'fontsize' : '10'}
dot.node(str(rxn), shape='plaintext', label=f'<<b>{str(rxn)}</b><br/>>', **atts)
for lhs_chem in rxn.lhs:
dot.edge(str(rxn), lhs_chem.formula)
for rhs_chem in rxn.rhs:
dot.edge(str(rxn), rhs_chem.formula)
dot.format = 'png'
dot.render('plot-graph')
def graficar(self):
dot = Digraph(node_attr={'shape': 'record'})
i = 0
st = ""
while i < len(self.tabla):
if len(self.tabla[i].cont) > 0:
if self.tabla[i].cont[0].bandera == False:
if i == len(self.tabla) - 1:
st = st + "<" + str(i) + "N" + "0" + "> " + str(
i) + "." + str(self.tabla[i].cont[0].usuario)
else:
st = st + "<" + str(i) + "N" + "0" + "> " + str(
i) + "." + str(
self.tabla[i].cont[0].usuario) + " |"
if len(self.tabla[i].cont) > 1:
j = 1
while (j < len(self.tabla[i].cont)):
if self.tabla[i].cont[j].bandera == False:
dot.node(
str(i) + "N" + str(j),
str(self.tabla[i].cont[j].usuario))
if j + 1 <= len(self.tabla[i].cont) - 1:
dot.edge(
str(i) + "N" + str(j),
str(i) + "N" + str(j + 1))
j = j + 1
dot.edge("tabla:" + str(i) + "N" + "0",
str(i) + "N" + str(1))
else:
st = st + "<" + str(i) + "N" + "0" + "> " + str(
i) + "." + str("Vacio") + " |"
else:
st = st + "<" + str(i) + "N" + "0" + "> " + str(i) + "." + str(
"Vacio") + " |"
i = i + 1
dot.node("tabla", st)
dot.format = 'png'
dot.render("hashprro")
def plot_as_directed_graph(tree,
file_prefix='',
drawing_name='tmp.png',
popup=True,
plot_edge_lengths=False):
leaves, admixture_nodes, coalescence_nodes, root, edges, edge_lengths = to_networkx_format(
tree)
filename, image_format = drawing_name.split('.')
G = Digraph('G', filename=filename)
leaves_graph = Digraph('l')
leaves_graph.node_attr.update(style='filled', color='cadetblue1')
for leaf in leaves:
leaves_graph.node(leaf)
admixture_graph = Digraph()
admixture_graph.node_attr.update(style='filled',
fillcolor='coral1',
shape='box')
for adm_n in admixture_nodes:
admixture_graph.node(adm_n)
coalescence_graph = Digraph()
coalescence_graph.node_attr.update(style='filled', fillcolor='greenyellow')
for cn in coalescence_nodes:
coalescence_graph.node(cn)
G.subgraph(leaves_graph)
G.subgraph(admixture_graph)
G.subgraph(coalescence_graph)
G.node('r', shape='egg', color='black', style='filled', fontcolor='white')
if plot_edge_lengths:
for (to_node, from_node), label in zip(edges, edge_lengths):
G.edge(to_node, from_node, label=label)
else:
G.edges(edges)
G.format = image_format
G.render(view=popup)
def graficar(self,usuario):
#self.verify()
g = Digraph('G', filename='graficaColaCircular.gv')
g.body.append('rankdir=LR')
g.attr('node', shape='Mdiamond', color='blue')
aux = self.front
if aux == None:
g.edge(usuario,str('Cola esta vacia'))
else:
g.body.append('"'+usuario+'"->"'+str(aux.nombre)+'"')
g.body.append('subgraph cluster_0 {')
g.body.append('style=filled; color=lightgrey; node [style=filled,color=white];')
while True:
g.edge(str(aux.nombre), str(aux.next.nombre))
aux = aux.next
if (aux == self.front):
break
g.body.append('}')
g.body.append('label = "Play List del Usuario";')
g.format = 'png'
g.render('test-output/Cola-PlayList/graficaColaCircular.gv', view=True)
def drawStockTree(self, N=10):
graph = Digraph(name='Stock Price Tree')
deltat = self.T / N
u = np.exp(self.sigma * np.sqrt(deltat))
d = 1 / u
a = np.exp(self.r * deltat)
p = (a - d) / (u - d)
# 計算出各節點之值並放入點中
for i in range(N + 1):
for j in range(i + 1):
graph.node('S{},{}'.format(i, j),
'{:0.2f}'.format(self.S * u**j * d**(i - j)))
# 連接點跟點
for i in range(N):
for j in range(i + 1):
graph.edge('S{},{}'.format(i, j), 'S{},{}'.format(i + 1, j))
graph.edge('S{},{}'.format(i, j),
'S{},{}'.format(i + 1, j + 1))
graph.format = 'png'
graph.render('C:/Users/User/Desktop/PriceTree{}'.format(N))
def print_state_diagram(self):
print('model_print_state_diagram')
dot = Digraph()
states = []
transitions = []
for s in self.states:
if s in self.accept:
label = (str(s), {'label': "q_accept"})
elif s in self.reject:
label = (str(s), {'label': "q_reject"})
else:
label = (str(s), {'label': str(s)})
if s == self.currstate[0]:
label[1]['color'] = 'red'
label[1]['weight'] = '5'
states += [label]
for preimage, image in self.delta.iteritems():
if preimage[1]:
label = u'%s \u2192 ' % (max(preimage[1], ''))
if image[1]:
label += u'%s,' % (max(image[1], ''))
if image[2] > 0:
label += u'R'
elif image[2] == 0:
label += u'S'
elif image[2] < 0:
label += u'L'
key = str(preimage[0]), str(image[0])
transitions += [((key), {'label': label})]
dot.format = 'gif'
add_edges(add_nodes(dot, states), transitions).render('imgs/temp')
def viz_search_tree(self, viz_file):
G = Digraph('G', filename=viz_file)
G.attr(rankdir='LR')
G.attr('node', shape='box')
G.format = 'pdf'
node_queue = Queue()
node_queue.put((self.root, None))
while not node_queue.empty():
node, parent = node_queue.get()
if node.open:
color = 'lightgrey'
else:
color = 'aquamarine'
if hasattr(node, 'mol'):
shape = 'box'
else:
shape = 'rarrow'
if node.succ:
color = 'lightblue'
if hasattr(node, 'mol') and node.is_known:
color = 'lightyellow'
G.node(node.serialize(), shape=shape, color=color, style='filled')
label = ''
if hasattr(parent, 'mol'):
label = '%.3f' % node.cost
if parent is not None:
G.edge(parent.serialize(), node.serialize(), label=label)
if node.children is not None:
for c in node.children:
node_queue.put((c, node))
G.render()
def save_graph(self,
out_prefix,
out_format='pdf',
title=None,
passage_labels=True,
link_labels=False,
remove_singletons=False,
char_limit=80):
"""Saves a graph representation of the story to a file."""
comment = title if title is not None else out_prefix
dot = Digraph(comment=comment)
# Find singletons
if remove_singletons:
pids_linked = set()
for passage in self.story["passages"]:
if passage["links"]:
pids_linked.add(passage["pid"])
for link in passage["links"]:
pids_linked.add(link["destination"]["pid"])
# Determine node name for each passage and create nodes
for passage in self.story["passages"]:
if remove_singletons and passage["pid"] not in pids_linked:
continue
label = self._trim_text(passage["name"],
char_limit) if passage_labels else None
dot.node(str(passage["pid"]), label)
# Create edges for passages
for passage in self.story["passages"]:
for link in passage["links"]:
label = self._trim_text(link["text"],
char_limit) if link_labels else None
dot.edge(str(passage["pid"]), str(link["destination"]["pid"]),
label)
dot.format = out_format
dot.render(f"{out_prefix}.gv")
def graphviz(self):
d = self.graph()
from graphviz import Digraph
dot = Digraph(self._name, strict=True)
dot.format = 'png'
def rec(nodes, parent):
for d in nodes:
if not isinstance(d, dict):
if '(dirty)' in d:
dot.node(d.replace('(dirty)', ''), color='red')
dot.edge(d.replace('(dirty)', ''),
parent.replace('(dirty)', ''),
color='red')
else:
dot.node(d)
dot.edge(d, parent.replace('(dirty)', ''))
else:
for k in d:
if '(dirty)' in k:
dot.node(k.replace('(dirty)', ''), color='red')
rec(d[k], k)
dot.edge(k.replace('(dirty)', ''),
parent.replace('(dirty)', ''),
color='red')
else:
dot.node(k)
rec(d[k], k)
dot.edge(k, parent.replace('(dirty)', ''))
for k in d:
if '(dirty)' in k:
dot.node(k.replace('(dirty)', ''), color='red')
else:
dot.node(k)
rec(d[k], k)
return dot
def visualize(dag, view_immediately=False, filename="dag"):
dot = Digraph(name='DAG', node_attr={
'shape':'box',\
'style': "rounded"})
dot.attr(rankdir='RL')
links = []
max_block_number = max(dag.blocks_by_number.keys())
for number in range(max_block_number + 1):
block_list_by_number = dag.blocks_by_number.get(number, [])
with dot.subgraph() as sub:
sub.attr(rank='same')
#place number
sub.node(str(number), shape="plain")
if number != 0:
dot.edge(str(number), str(number - 1), style="invis")
#add blocks on this level if any
for block in block_list_by_number:
links += block.block.prev_hashes
blockhash = block.get_hash()
color = 'black'
if blockhash == dag.genesis_block().get_hash():
color = 'blue'
sub.node(blockhash.hex()[:SUFFIX_LEN], color=color)
for _, signed_block in dag.blocks_by_hash.items():
block_hash = signed_block.get_hash()
for prev_hash in signed_block.block.prev_hashes:
dot.edge(block_hash.hex()[:SUFFIX_LEN],
prev_hash.hex()[:SUFFIX_LEN],
constraint='true')
#set view to True to instantly render and open pdf
#Note, that you will need 'graphviz' package installed
dot.format = "png"
dot.render('visualization/' + filename + '.dot', view=view_immediately)
def plot_graph_bfs(g, vertex_count, depth=5):
s, t = 0, vertex_count - 1
used = [False for _ in range(vertex_count)]
used[s] = True
d = Digraph()
q_cur = [s]
q_next = []
for _ in range(depth):
print('q_cur', len(q_cur))
for u in q_cur:
for v in g[u]:
if not used[v]:
used[v] = True
d.edge(str(u), str(v))
q_next.append(v)
q_cur = q_next
q_next = []
name = f'bfs_prefix_{depth}'
d.format = 'png'
d.render(f'output/graphviz/{name}.gv', view=True)
def GraphViz(f_wrap, name='Graph'):
d = Graph(f_wrap)
from graphviz import Digraph
dot = Digraph(name, strict=True)
dot.format = 'png'
def rec(nodes, parent):
for d in nodes:
if not isinstance(d, dict):
dot.node(d)
dot.edge(d, parent)
else:
for k in d:
dot.node(k)
rec(d[k], k)
dot.edge(k, parent)
for k in d:
dot.node(k)
rec(d[k], k)
return dot
def toGraphvizSource(self):
"""
Generate graphviz code that can be used to draw the automaton.
:return: graphviz code
"""
dot = Digraph(engine="neato")
dot.graph_attr.update(size="4,4")
for v_idx in range(len(self.vertices)):
vertex_style = "doublecircle" if len(self.vertices[v_idx].output_fun) > 0 else "circle"
if v_idx == 0: vertex_style = "point"
dot.node(str(v_idx), str(v_idx), shape=vertex_style)
for v_idx in range(len(self.vertices)):
for c in self.vertices[v_idx].next:
to_idx = self.vertices[v_idx].next[c]
dot.edge(str(v_idx), str(to_idx), label=c, constraint="false")
dot.format = "png"
dot.render('automaton')
return dot.source
# encoding: utf8
from graphviz import Digraph, Graph
graph = Digraph(comment='Test')
graph.format = 'png'
graph1 = Digraph('S1')
graph1.node('A')
graph1.node('Test1')
graph1.node('Test2')
graph2 = Digraph('S2')
graph2.node('B')
graph2.node('C')
graph.subgraph(graph1)
graph.subgraph(graph2)
graph.edge(head_name='S1', tail_name='S2')
graph.render('test')
if num_cycle==cycle_max:
redoGen=True
break
if(redoGen==True):
genSuccess=False
continue
else:
genSuccess=True
break
labeled_trans = num_to_labels(nodematrix, num_nodes)
f = Digraph('finite_state_machine', filename='tmp/fsm')
f.format='pdf'
f.attr('graph',overlap='false',size="7,8!")
f.attr('node', shape='circle')
f.attr('edge',overlap='false')
node_names=[]
for i in range(0,num_nodes):
if(i==0):
node_names.append("START")
else:
node_names.append("S{0}".format(i-1))
for i in range (0, num_nodes, 1):
for j in range(0, num_nodes, 1):
if nodematrix[i][j] > 0:
f.edge(node_names[i], node_names[j]," "+ labeled_trans[i][j]+ " ")
def drawDiagram(modelXbrl, diagramFile, diagramNetwork=None, viewDiagram=False):
if diagramNetwork not in diagramNetworks:
modelXbrl.error("objectmaker:diagramNetwork",
"Diagram network %(diagramNetwork)s not recognized, please specify one of %(recognizedDiagramNetworks)s",
modelXbrl=modelXbrl, diagramNetwork=diagramNetwork, recognizedDiagramNetworks=", ".join(diagramNetworks))
return
try:
from graphviz import Digraph, backend
except ImportError:
modelXbrl.error("objectmaker:missingLibrary",
"Missing library, please install graphviz for python importing",
modelXbrl=modelXbrl)
return
isUML = diagramNetwork == "uml"
isBaseSpec = diagramNetwork in ("pre", "cal", "def")
graphName = os.path.splitext(modelXbrl.modelDocument.basename)[0]
mdl = Digraph(comment=graphName)
mdl.attr("graph")
mdl.node('node_title', graphName, shape="none", fontname="Bitstream Vera Sans")
mdl.attr('node', shape="record")
mdl.attr('node', fontname="Bitstream Vera Sans")
mdl.attr('node', fontsize="8")
if isUML:
arcroleName = "http://xbrl.us/arcrole/Property"
propertiesRelationshipSet = modelXbrl.relationshipSet(arcroleName)
if not propertiesRelationshipSet:
modelXbrl.modelManager.addToLog(_("no relationships for {0}").format(arcroleName))
return False
def node(mdl, id, modelObject):
if modelObject is not None:
mdl.attr("node", style="") # white classes
if isUML:
_properties = "".join("+{} {}\l".format(rel.toModelObject.qname.localName, rel.toModelObject.niceType)
for rel in propertiesRelationshipSet.fromModelObject(modelObject)
if rel.toModelObject is not None)
mdl.node(id, "{{{}|{}}}".format(modelObject.qname.localName, _properties))
elif isBaseSpec and isinstance(modelObject, ModelConcept):
concept = modelObject
if concept.isHypercubeItem:
_properties = "Hypercube"
elif concept.isExplicitDimension:
_properties = "Dimension, Explicit"
elif concept.isExplicitDimension:
_properties = "Dimension, Typed ({} {})".format(typedDomainElement.qname, typedDomainElement.niceType)
elif concept.isEnumeration:
_properties = "Enumeration ({})".format(concept.enumDomain.qname)
else:
_properties = "{}{}".format("Abstract " if modelObject.isAbstract else "",
modelObject.niceType)
mdl.node(id, "{{{}|{}}}".format(modelObject.qname.localName, _properties))
elif isinstance(modelObject, ModelDocument.ModelDocument):
mdl.node(id, "{{{}|{}}}".format(modelObject.basename, modelObject.gettype()))
elif isinstance(modelObject, str): # linkrole definition
mdl.node(id, "{{{}}}".format(modelObject))
else:
mdl.node(id, "{{{}}}".format(modelObject.qname.localName))
nodes = set()
edges = set()
arcroles = diagramNetworks[diagramNetwork]
lang = None # from parameter for override
# sort URIs by definition
linkroleUris = set()
if isBaseSpec:
for arcrole in arcroles:
graphRelationshipSet = modelXbrl.relationshipSet(arcrole)
for linkroleUri in graphRelationshipSet.linkRoleUris:
modelRoleTypes = modelXbrl.roleTypes.get(linkroleUri)
if modelRoleTypes:
roledefinition = (modelRoleTypes[0].genLabel(lang=lang, strip=True) or modelRoleTypes[0].definition or linkroleUri)
else:
roledefinition = linkroleUri
linkroleUris.add((roledefinition, linkroleUri))
else:
linkroleUris.add((None, None))
for roledefinition, linkroleUri in sorted(linkroleUris):
for arcrole in arcroles:
relationshipType = arcrole.rpartition("/")[2].lower()
edgeType = networkEdgeTypes[diagramNetwork][relationshipType]
graphRelationshipSet = modelXbrl.relationshipSet(arcrole, linkroleUri)
roleprefix = (linkroleUri.replace("/","_").replace(":","_") + "_") if linkroleUri else ""
if not graphRelationshipSet:
continue
if linkroleUri is not None:
node(mdl, roleprefix, roledefinition or roleUri)
for rootConcept in graphRelationshipSet.rootConcepts:
childName = roleprefix + rootConcept.qname.localName
node(mdl, childName, rootConcept)
nodes.add(childName)
mdl.edge(roleprefix, childName,
dir=edgeType.get("dir"), arrowhead=edgeType.get("arrowhead"), arrowtail=edgeType.get("arrowtail"))
for rel in graphRelationshipSet.modelRelationships:
parent = rel.fromModelObject
parentName = roleprefix + parent.qname.localName
child = rel.toModelObject
if child is None:
continue
childName = roleprefix + child.qname.localName
if parentName not in nodes:
node(mdl, parentName, parent)
nodes.add(parentName)
if childName not in nodes:
node(mdl, childName, child)
nodes.add(childName)
edgeKey = (relationshipType, parentName, childName)
if edgeKey not in edges:
edges.add(edgeKey)
mdl.edge(parentName, childName,
dir=edgeType.get("dir"), arrowhead=edgeType.get("arrowhead"), arrowtail=edgeType.get("arrowtail"))
if diagramNetwork == "dts":
def viewDtsDoc(modelDoc, parentDocName, grandparentDocName):
docName = modelDoc.basename
docType = modelDoc.gettype()
if docName not in nodes:
node(mdl, docName, modelDoc)
if parentDocName:
edgeKey = (parentDocName, docType, docName)
if edgeKey in edges:
return
edges.add(edgeKey)
edgeType = networkEdgeTypes[diagramNetwork]["all-types"]
mdl.edge(parentDocName, docName,
dir=edgeType.get("dir"), arrowhead=edgeType.get("arrowhead"), arrowtail=edgeType.get("arrowtail"))
for referencedDoc in modelDoc.referencesDocument.keys():
if referencedDoc.basename != parentDocName: # skip reverse linkbase ref
viewDtsDoc(referencedDoc, docName, parentDocName)
viewDtsDoc(modelXbrl.modelDocument, None, None)
mdl.format = "pdf"
try:
mdl.render(diagramFile.replace(".pdf", ".gv"), view=viewDiagram)
except backend.ExecutableNotFound as ex:
modelXbrl.warning("objectmaker:graphvizExecutable",
"Diagram saving requires installation of graphviz, error: %(error)s:",
modelXbrl=modelXbrl, error=ex)
def main(metadata_path, output_path, print_source=False):
metadata_path = os.path.abspath(metadata_path)
metadata_dir = os.path.dirname(metadata_path)
meta_loader = MetaLoader()
data = meta_loader.load(metadata_path)
action_name = data['name']
entry_point = data['entry_point']
workflow_metadata_path = os.path.join(metadata_dir, entry_point)
chainspec = meta_loader.load(workflow_metadata_path)
chain_holder = ChainHolder(chainspec, 'workflow')
graph_label = '%s action-chain workflow visualization' % (action_name)
graph_attr = {
'rankdir': 'TD',
'labelloc': 't',
'fontsize': '15',
'label': graph_label
}
node_attr = {}
dot = Digraph(comment='Action chain work-flow visualization',
node_attr=node_attr, graph_attr=graph_attr, format='png')
# dot.body.extend(['rankdir=TD', 'size="10,5"'])
# Add all nodes
node = chain_holder.get_next_node()
while node:
dot.node(node.name, node.name)
node = chain_holder.get_next_node(curr_node_name=node.name)
# Add connections
node = chain_holder.get_next_node()
processed_nodes = sets.Set([node.name])
nodes = [node]
while nodes:
previous_node = nodes.pop()
success_node = chain_holder.get_next_node(curr_node_name=previous_node.name,
condition='on-success')
failure_node = chain_holder.get_next_node(curr_node_name=previous_node.name,
condition='on-failure')
# Add success node (if any)
if success_node:
dot.edge(previous_node.name, success_node.name, constraint='true',
color='green', label='on success')
if success_node.name not in processed_nodes:
nodes.append(success_node)
processed_nodes.add(success_node.name)
# Add failure node (if any)
if failure_node:
dot.edge(previous_node.name, failure_node.name, constraint='true',
color='red', label='on failure')
if failure_node.name not in processed_nodes:
nodes.append(failure_node)
processed_nodes.add(failure_node.name)
if print_source:
print(dot.source)
if output_path:
output_path = os.path.join(output_path, action_name)
else:
output_path = output_path or os.path.join(os.getcwd(), action_name)
dot.format = 'png'
dot.render(output_path)
print('Graph saved at %s' % (output_path + '.png'))
import simplejson
import sys
import pydot
from graphviz import Digraph
dot = Digraph(comment='Ceph Crush Map')
dot.graph_attr['size'] = '100,500'
dot.graph_attr['resolution'] = '200'
dot.graph_attr['bb'] = '0,0,4,8'
dot.format = 'png'
m = sys.argv[1]
data_file = open(m)
cm = simplejson.load(data_file)
print (str(cm)+'\n')
print (str(cm.keys())+'\n')
print (str(cm['devices'])+'\n')
graph = pydot.Dot('ceph_crushmap', graph_type='digraph')
for i in range(len(cm['devices'])):
dot.node(str(cm['devices'][i]['id']), 'device: '+cm['devices'][i]['name'], {'style':'filled','fillcolor':'Yellow'})
for i in range(len(cm['buckets'])):
dot.node(str(cm['buckets'][i]['id']), cm['buckets'][i]['type_name']+': '+cm['buckets'][i]['name'], {'style':'filled','fillcolor':'Red'})
for i in range(len(cm['rules'])):
dot.node('rule'+str(i), str(cm['rules'][i]), {'style':'filled','shape':'box', 'fillcolor':'Blue'})
