def _read(self, string="", fname=""):
""" Reads a graph from string, file or stdin """
if string:
self.handle = gv.readstring(string)
elif fname == "stdin":
data = sys.stdin.read()
self.handle = gv.readstring(data)
else:
self.handle = gv.read(fname)
# gv returns None if eg. the input does not exist
if not self.handle:
raise ValueError("Error with file " + fname)
def handle(self, **options):
gr = graph()
cats_by_id = dict((c.id, c) for c in Category.objects.all())
# Add nodes
dups = count()
for c in cats_by_id.itervalues():
try:
gr.add_node(c)
except AdditionError:
dups.next()
parent = cats_by_id.get(c.parent_id)
print 'WARNING: duplicate node :: <Category %i | %s>' % (c.id,
c)
print '\twith parent ' + '<Category %i | %s>' % (
parent.id, parent) if parent else 'None'
if dups.next() > 0: return
# Add edges
# gr.add_edge((CONCRETE_NODE, ROOT_NODE))
for c in cats_by_id.itervalues():
parent = cats_by_id.get(c.parent_id)
if parent:
gr.add_edge((c, parent))
# import ipdb; ipdb.set_trace()
# The whole tree from the root
st, order = breadth_first_search(
gr, root=Category.objects.get(title="Abstract"))
gst = digraph()
gst.add_spanning_tree(st)
dot = write(gst)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'pdf', os.path.join(output_dir, 'abstract.pdf'))
st, order = breadth_first_search(
gr, root=Category.objects.get(title="Concrete"))
gst = digraph()
gst.add_spanning_tree(st)
dot = write(gst)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'pdf', os.path.join(output_dir, 'concrete.pdf'))
def drawGraphFromSM(SM, names, outFile): fig = plt.figure(1) plot1 = plt.imshow(SM, origin='upper', cmap=cm.gray, interpolation='nearest') plt.show() gr = graph() namesNew = [] for i,f in enumerate(names): if sum(SM[i,:])>0: gr.add_nodes([f]) namesNew.append(f) Max = SM.max() Mean = mean(SM) Threshold = Mean * 1.5 for i in range(len(names)): for j in range(len(names)): if i<j: if SM[i][j] > 0: gr.add_edge((names[i], names[j])) # Draw as PNG dot = write(gr) gvv = gv.readstring(dot) gv.layout(gvv,'dot') gv.render(gvv,'png', outFile)
def visualize(self):
xmldoc = minidom.parse(self.path)
self.create(xmldoc.childNodes[0])
dot = 'digraph graphname {{{}{}\n}}\n'.format(self.nodes, self.edges)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', self.output)
def draw(self, filename):
print "initial state:", self.initial_state
print "final states", self.final_state
print "transition table:", self.transition_table
vertexes = self.transition_table.keys()
edges = self._edges()
gr = digraph()
#gr.add_nodes([str(vertex) for vertex in vertexes])
for vertex in vertexes:
attrs = []
if ((isinstance(self.final_state, list) and vertex in self.final_state) or
(isinstance(self.final_state, int) and vertex == self.final_state)):
attrs.append('final')
gr.add_node(str(vertex), attrs=attrs)
for edge, label in edges.items():
label = ', '.join(label)
gr.add_edge(edge=edge, label=label)
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', '%s.png' % filename)
def draw(self, filename):
print "initial state:", self.initial_state
print "final states", self.final_state
print "transition table:", self.transition_table
vertexes = self.transition_table.keys()
edges = self._edges()
gr = digraph()
#gr.add_nodes([str(vertex) for vertex in vertexes])
for vertex in vertexes:
attrs = []
if ((isinstance(self.final_state, list)
and vertex in self.final_state)
or (isinstance(self.final_state, int)
and vertex == self.final_state)):
attrs.append('final')
gr.add_node(str(vertex), attrs=attrs)
for edge, label in edges.items():
label = ', '.join(label)
gr.add_edge(edge=edge, label=label)
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', '%s.png' % filename)
def rdf_to_graph_file(rdfLink, storePath, fileType='png'):
stre = parse_link(rdfLink)
dotSer = serialize_stream(stre, 'dot')
gvv = gv.readstring(dotSer)
gv.layout(gvv,'dot')
gv.render(gvv,fileType,storePath)
def drawGraph(self, inputs):
fileName = 'planetModel.png'
gr = graph()
self.addGraphNode(1, gr, inputs)
# Draw as PNG
#with open("./planetModel.viz", 'wb') as f:
#dot = write(gr,f)
#f.write(dot)
#gvv = gv.readstring(dot)
#gv.layout(gvv,'dot')
#gv.render(gvv,'png', fileName)
#f.close()
gst = digraph()
self.addGraphNode(1, gst, inputs)
with open("./planetModel.viz", 'wb') as f:
#st, order = breadth_first_search(gst, root=1)
#gst2 = digraph()
#gst2.add_spanning_tree(gst.nodes())
#gst2.(1, 'post')
dot = write(gst, f)
f.write(dot)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', fileName)
f.close()
return fileName
def saveTree(self, filename):
'''
Saves the image of AST built with the current node as a root node.
@param filename:
filename to which to save. 'png' extension will be appended.
'''
import graph
import gv
gr = graph.digraph()
queue = [self]
i = 0
h = {}
while len(queue):
n = queue.pop()
h[n] = i
gr.add_node(i, [('label', n.value)])
if n.children is not None:
queue.extend(n.children)
i += 1
queue = [self]
while len(queue):
n = queue.pop()
if n.children is not None:
for c in n.children:
gr.add_edge(h[n], h[c])
queue.append(c)
dot = gr.write(fmt='dot')
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', str(filename) + '.png')
def plot_graph(gr):
"""
draws the graph to file
"""
p = 100.0 / (len(gr.nodes())+1)
gr_ext = graph()
for node in gr.nodes():
if coin(p):
if not gr_ext.has_node(node):
gr_ext.add_node(node,attrs=gr.node_attributes(node))
for n in [ ed[0] for ed in gr.edges() if ed[1] == node ]:
if coin(0.3):
if not gr_ext.has_node(n):
gr_ext.add_node(n,attrs=gr.node_attributes(n))
#print "Edges:",gr_ext.edges()
if not gr_ext.has_edge((node,n)):
gr_ext.add_edge((node,n))
dot = write(gr_ext)
gvv = gv.readstring(dot)
gv.layout(gvv,'dot')
if args[1]== 'karate.txt':
gv.render(gvv,'png','community1.png')
elif args[1] == 'email.txt':
gv.render(gvv,'png','community2.png')
elif args[1] == 'hep-th-citations.txt':
gv.render(gvv,'png','community3.png')
elif args[1] == 'amazon1.txt':
gv.render(gvv,'png','community4.png')
elif args[1] == 'p2p-Gnutella30.txt':
gv.render(gvv,'png','community5.png')
def show(self):
'Simple method to generate a dotgraph and render it with graphviz'
import gv
import os
import time
dot = self.get_dot()
# write the dotfile out for testing
self.write_dot('/tmp/dag.dot')
# Apply the dot layout to the graph
gvo = gv.readstring(dot) # graphviz object
gv.layout(gvo, 'dot')
# render the layout into the node attributes
gv.render(gvo)
# write to a temp file and display in default viewer
fileout = '/tmp/out.png'
if os.path.exists(fileout):
os.remove(fileout)
gv.render(gvo, 'png', fileout)
time.sleep(1)
os.system('xdg-open %s 2> /dev/null' % fileout)
def run(self):
self.assert_has_content()
# global nthUnnamed
# try:
# filename = self.arguments[0]
# except:
# filename = ('dot%d.png' % nthUnnamed)
# nthUnnamed += 1
# content = '\n'.join(self.content)
# filetype = filename[filename.rfind('.')+1:]
# args = ['dot', '-o'+filename, '-T'+filetype]
# dot = sp.Popen(args, 0, None, sp.PIPE)
# dot.stdin.write( content )
# dot.stdin.close()
# ret = dot.wait()
# if ret:
# return [nodes.error('some error occured')]
# else:
# return [nodes.raw('', '<img src="%s" alt="%s"/>'%(filename, filename), format='html')]
content = "\n".join(self.content).encode("utf-8")
graph = gv.readstring(content)
gv.layout(graph, 'dot')
res = gv.renderdata(graph, 'svg')
res = res[res.index('<svg'):]
return [nodes.raw('', res, format='html')]
def drawGraph(self, inputs):
fileName = 'planetModel.png'
gr = graph()
self.addGraphNode(1,gr, inputs)
# Draw as PNG
#with open("./planetModel.viz", 'wb') as f:
#dot = write(gr,f)
#f.write(dot)
#gvv = gv.readstring(dot)
#gv.layout(gvv,'dot')
#gv.render(gvv,'png', fileName)
#f.close()
gst = digraph()
self.addGraphNode(1,gst, inputs)
with open("./planetModel.viz", 'wb') as f:
#st, order = breadth_first_search(gst, root=1)
#gst2 = digraph()
#gst2.add_spanning_tree(gst.nodes())
#gst2.(1, 'post')
dot = write(gst,f)
f.write(dot)
gvv = gv.readstring(dot)
gv.layout(gvv,'dot')
gv.render(gvv,'png', fileName)
f.close()
return fileName
def str_to_graph_file(rdfString, uri, storePath, fileType='png'):
stre = parse_string(rdfString, uri)
dotSer = serialize_stream(stre, 'dot')
gvv = gv.readstring(dotSer)
gv.layout(gvv,'dot')
gv.render(gvv,fileType,storePath)
def handle(self, **options):
gr = graph()
cats_by_id = dict((c.id, c) for c in Category.objects.all())
# Add nodes
dups = count()
for c in cats_by_id.itervalues():
try:
gr.add_node(c)
except AdditionError:
dups.next()
parent = cats_by_id.get(c.parent_id)
print 'WARNING: duplicate node :: <Category %i | %s>' % (c.id, c)
print '\twith parent ' + '<Category %i | %s>' % (parent.id, parent) if parent else 'None'
if dups.next() > 0: return
# Add edges
# gr.add_edge((CONCRETE_NODE, ROOT_NODE))
for c in cats_by_id.itervalues():
parent = cats_by_id.get(c.parent_id)
if parent:
gr.add_edge((c, parent))
# import ipdb; ipdb.set_trace()
# The whole tree from the root
st, order = breadth_first_search(gr, root=Category.objects.get(title="Abstract"))
gst = digraph()
gst.add_spanning_tree(st)
dot = write(gst)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'pdf', os.path.join(output_dir, 'abstract.pdf'))
st, order = breadth_first_search(gr, root=Category.objects.get(title="Concrete"))
gst = digraph()
gst.add_spanning_tree(st)
dot = write(gst)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'pdf', os.path.join(output_dir, 'concrete.pdf'))
def save_as_pdf(gr,filename,show_weights=False):
from pygraph.readwrite.dot import write
import gv
dot = write(gr, weighted=show_weights)
gvv = gv.readstring(dot)
gv.layout(gvv,'fdp')
gv.render(gvv,'pdf',filename)
def rdf_to_graph_str(rdfLink):
stre = parse_link(rdfLink)
dotSer = serialize_stream(stre, 'dot')
gvv = gv.readstring(dotSer)
gv.layout(gvv,'dot')
graphStr = gv.renderdata(gvv,'svg')
return graphStr
def generate_graph_image(wcbg, png_file):
g = digraph()
g.add_graph(wcbg)
for edge in g.edges():
g.set_edge_weight(edge, wcbg.edge_weight(edge))
dot = write(g, True)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
png_file = png_file + '.png'
gv.render(gvv, 'png', png_file)
def generate_graph_image (wcbg, png_file): g = digraph () g.add_graph (wcbg) for edge in g.edges (): g.set_edge_weight (edge, wcbg.edge_weight (edge)) dot = write (g, True) gvv = gv.readstring (dot) gv.layout (gvv, 'dot') png_file = png_file + '.png' gv.render (gvv, 'png', png_file)
def dot_pdf(wkf): # Write to DOT language and create a pdf file of the digraph with its name dot = write(wkf) with open(wkf.name + '.dot', 'w') as f: f.write(dot) gvv = gv.readstring(dot) gv.layout(gvv,'dot') gv.render(gvv,'pdf', wkf.name + '.pdf')
def visualize_with_pygraph(args):
data, nodes = get_input(args.file)
graph = digraph()
graph.add_nodes(nodes)
for start, stop, distance in emit_edge(data):
graph.add_edge((start, stop), distance)
dot = write(graph, weighted=True)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', args.out)
def matriz_relaciones(self,id_item):
"""
Obtiene una matriz de la relaciones.
"""
if id_item is not None:
id_item=int(id_item)
antecesores=Relaciones.get_antecesores(id_item)
sucesores=Relaciones.get_sucesores(id_item)
item=Item.get_item_by_id(id_item)
relacionados=[]
usados=[]
n = len(antecesores)+len(sucesores)+1
for antecesor in antecesores:
if antecesor not in relacionados:
if (antecesor.estado_oculto=="Activo"):
relacionados.append(antecesor)
usados.append(antecesor.nombre_item)
if item not in relacionados:
relacionados.append(item)
usados.append(item.nombre_item)
for sucesor in sucesores:
if sucesor not in relacionados:
if (sucesor.estado_oculto=="Activo"):
relacionados.append(sucesor)
usados.append(sucesor.nombre_item)
#Graph creation
gr = graph()
# Add nodes and edges
for item in usados:
gr.add_nodes([item])
# Add relation and edges
for item in relacionados:
padres= Relaciones.get_mis_padres(item.id_item)
if len(padres)>0:
for padre in padres:
gr.add_edge((item.nombre_item, padre.nombre_item))
else:
#remover nodo
print("hola")
# Draw as PNG
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv,'dot')
gv.render(gvv,'png','/home/hermann/saip2011/saip2011/public/images/arbol.png')
def dot_pdf(wkf): # Write to 'dot' language and create a pdf file of the digraph with its name dot = write(wkf) dot_file = open(wkf.name + '.dot', "w") dot_file.write(dot) dot_file.close() gvv = gv.readstring(dot) gv.layout(gvv,'dot') gv.render(gvv,'pdf', wkf.name + '.pdf')
def savePythonGraph(self, filename):
'''
Saves CFG as a png image by means of graphviz.
@param filename: CFG will be saved to "filename.png"
'''
try:
import graph
import gv
except ImportError:
print '# Err: no modules for drawing graphs found... try:'
print '#> sudo apt-get install python-setuptools ' \
'# needed for the next line'
print '#> sudo easy_install python-graph '\
'# This actually installs the thing'
print '#> sudo apt-get install libgv-python ' \
'# for graphviz in python support'
print '#> sudo apt-get install python-pydot # for pydot'
return None
pattern1 = re.compile(r'\n')
pattern2 = re.compile(r'\"')
gr = graph.digraph()
for n in self.nodes:
if self.nodes[n].code != '':
if self.nodes[n].condition is not None:
txt = re.sub(pattern1, r'\\l', self.nodes[n].code + \
'\n\n' + str(self.nodes[n].condition))
txt = re.sub(pattern2, r'\\"', txt)
gr.add_node(n, [('label', '"' + txt + '"')])
#print '1:::'
#print txt
else:
txt = re.sub(pattern1, r'\\l', self.nodes[n].code)
txt = re.sub(pattern2, r'\\"', txt)
gr.add_node(n, [('label', '"' + txt + '"')])
#print '2:::'
#print txt
else:
txt = re.sub(pattern1, r'\\l', str(self.nodes[n].condition))
txt = re.sub(pattern2, r'\\"', txt)
gr.add_node(n, [('label', '"' + txt + '"')])
if not self.nodes[n].conditional:
gr.add_node_attribute(n, ('shape', 'box'))
for n in self.nodes:
for e in self.nodes[n].outgoing:
gr.add_edge(n, e.toNode, label=e.type)
dot = gr.write(fmt='dot')
#print '>>>>>'
#print dot
#print '<<<<<'
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', str(filename) + '.png')
def savePythonGraph(self, filename):
'''
Saves CFG as a png image by means of graphviz.
@param filename: CFG will be saved to "filename.png"
'''
try:
import graph
import gv
except ImportError:
print '# Err: no modules for drawing graphs found... try:'
print '#> sudo apt-get install python-setuptools ' \
'# needed for the next line'
print '#> sudo easy_install python-graph '\
'# This actually installs the thing'
print '#> sudo apt-get install libgv-python ' \
'# for graphviz in python support'
print '#> sudo apt-get install python-pydot # for pydot'
return None
pattern1 = re.compile(r'\n')
pattern2 = re.compile(r'\"')
gr = graph.digraph()
for n in self.nodes:
if self.nodes[n].code != '':
if self.nodes[n].condition is not None:
txt = re.sub(pattern1, r'\\l', self.nodes[n].code + \
'\n\n' + str(self.nodes[n].condition))
txt = re.sub(pattern2, r'\\"', txt)
gr.add_node(n, [('label', '"' + txt + '"')])
#print '1:::'
#print txt
else:
txt = re.sub(pattern1, r'\\l', self.nodes[n].code)
txt = re.sub(pattern2, r'\\"', txt)
gr.add_node(n, [('label', '"' + txt + '"')])
#print '2:::'
#print txt
else:
txt = re.sub(pattern1, r'\\l', str(self.nodes[n].condition))
txt = re.sub(pattern2, r'\\"', txt)
gr.add_node(n, [('label', '"' + txt + '"')])
if not self.nodes[n].conditional:
gr.add_node_attribute(n, ('shape', 'box'))
for n in self.nodes:
for e in self.nodes[n].outgoing:
gr.add_edge(n, e.toNode, label=e.type)
dot = gr.write(fmt='dot')
#print '>>>>>'
#print dot
#print '<<<<<'
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', str(filename) + '.png')
def draw_graph(gr):
"""
draws the graph to file
"""
print "Nodes levels after 100 steps:"
for node in gr.nodes():
print "Node: %i - level:%.1f" % (node, dict(gr.node_attributes(node)).get('level'))
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv,'dot')
gv.render(gvv,'png','pumping.png')
def export(self, graph, path, type):
"""
Export the graph
"""
dot = write(graph)
gvv = gv.readstring(dot)
gv.setv(gvv,'rankdir','LR')
gv.layout(gvv,'dot')
graphname = path + '/' + type + '.svg-' + str(time.time())
gv.render(gvv, 'svg', graphname)
return graphname
def _dep_graph(fn, specs, silent=False):
"""
Create a dependency graph for the given easyconfigs.
"""
# check whether module names are unique
# if so, we can omit versions in the graph
names = set()
for spec in specs:
names.add(spec['ec']['name'])
omit_versions = len(names) == len(specs)
def mk_node_name(spec):
if spec.get('external_module', False):
node_name = "%s (EXT)" % spec['full_mod_name']
elif omit_versions:
node_name = spec['name']
else:
node_name = ActiveMNS().det_full_module_name(spec)
return node_name
# enhance list of specs
all_nodes = set()
for spec in specs:
spec['module'] = mk_node_name(spec['ec'])
all_nodes.add(spec['module'])
spec['unresolved_deps'] = [
mk_node_name(s) for s in spec['unresolved_deps']
]
all_nodes.update(spec['unresolved_deps'])
# build directed graph
dgr = digraph()
dgr.add_nodes(all_nodes)
for spec in specs:
for dep in spec['unresolved_deps']:
dgr.add_edge((spec['module'], dep))
# write to file
dottxt = dot.write(dgr)
if fn.endswith(".dot"):
# create .dot file
write_file(fn, dottxt)
else:
# try and render graph in specified file format
gvv = gv.readstring(dottxt)
gv.layout(gvv, 'dot')
gv.render(gvv, fn.split('.')[-1], fn)
if not silent:
print "Wrote dependency graph for %d easyconfigs to %s" % (len(specs),
fn)
def draw_graph(gr):
"""
draws the graph to file
"""
print "Nodes levels after 100 steps:"
for node in gr.nodes():
print "Node: %i - level:%.1f" % (node, dict(
gr.node_attributes(node)).get('level'))
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', 'pumping.png')
def main(args):
print "Productions:"
print prods
prods.check()
gvv = gv.readstring(pygraph.readwrite.dot.write(productions_graph(prods)))
gv.layout(gvv, "dot")
gv.render(gvv, "svg", "input_productions.svg")
if False:
# for layout in "circo dot fdp neato nop nop1 nop2 twopi".split():
for layout in "circo dot fdp neato twopi".split():
gv.layout(gvv, layout)
gv.render(gvv, "png", "input_productions_%s.png" % (layout,))
print "Non-terminals: %s." % (", ".join(map(str, prods.nonterms())))
print "Terminals: %s." % (", ".join(map(str, prods.terms())))
for nonterm in prods.nonterms():
print "FIRST(%s) = {%s}." % (nonterm, ", ".join(map(str, first(prods, nonterm))))
for nonterm in prods.nonterms():
print "FOLLOW(%s) = {%s}." % (nonterm, ", ".join(map(str, follow(prods, nonterm))))
ptable = parse_table(prods)
print "Grammar parse table:"
print format_parse_table(prods, ptable)
input_terms = [var, add, var, mult, var, word_end]
print "Input terminals: %s." % (", ".join(map(str, input_terms)),)
prod_idxs = parse_word(prods, ptable, input_terms)
print "Productions that generates input:"
print format_productions_idxs(prods, prod_idxs)
prods_dot = productions_idxs_dot_graph(prods, prod_idxs)
# with open("syntax_tree.dot", "w") as f:
# f.write(prods_dot)
gvv = gv.readstring(prods_dot)
gv.layout(gvv, "dot")
gv.render(gvv, "svg", "syntax_tree.svg")
def assert_graphs(self, result, target):
(_state, graph) = result
graph = repr(graph)
ok = graph == target
if not ok:
print('target:\n' + target)
print('result:\n' + graph)
try:
graph = readstring(graph)
layout(graph, 'neato')
render(graph, 'gtk')
except Exception, e:
print(e)
assert False
def _dep_graph(fn, specs, silent=False):
"""
Create a dependency graph for the given easyconfigs.
"""
# check whether module names are unique
# if so, we can omit versions in the graph
names = set()
for spec in specs:
names.add(spec['ec']['name'])
omit_versions = len(names) == len(specs)
def mk_node_name(spec):
if spec.get('external_module', False):
node_name = "%s (EXT)" % spec['full_mod_name']
elif omit_versions:
node_name = spec['name']
else:
node_name = ActiveMNS().det_full_module_name(spec)
return node_name
# enhance list of specs
all_nodes = set()
for spec in specs:
spec['module'] = mk_node_name(spec['ec'])
all_nodes.add(spec['module'])
spec['unresolved_deps'] = [mk_node_name(s) for s in spec['unresolved_deps']]
all_nodes.update(spec['unresolved_deps'])
# build directed graph
dgr = digraph()
dgr.add_nodes(all_nodes)
for spec in specs:
for dep in spec['unresolved_deps']:
dgr.add_edge((spec['module'], dep))
# write to file
dottxt = dot.write(dgr)
if fn.endswith(".dot"):
# create .dot file
write_file(fn, dottxt)
else:
# try and render graph in specified file format
gvv = gv.readstring(dottxt)
gv.layout(gvv, 'dot')
gv.render(gvv, fn.split('.')[-1], fn)
if not silent:
print "Wrote dependency graph for %d easyconfigs to %s" % (len(specs), fn)
def assert_graphs(self, result, target):
(_state, graph) = result
graph = repr(graph)
ok = graph == target
if not ok:
print('target:\n' + target)
print('result:\n' + graph)
try:
graph = readstring(graph)
layout(graph, 'neato')
render(graph, 'gtk')
except Exception, e:
print(e)
assert False
def generate(self, filename):
'''
Displays the graph on the canvas
Uses python-igraph fruchterman-reingold algorithm to decide about
position of the nodes, then draw these nodes on the canvas and
draw connections between them
Author: Jan Vorcak <*****@*****.**>
'''
g = gv.readstring(self.source)
gv.layout(g, 'dot')
gv.render(g)
context = CanvasContext().dictionary
node = gv.firstnode(g)
while node is not None:
props = {
'filepath' : gv.getv(node, 'filepath'),
'title' : gv.getv(node, 'label'),
'lineno' : gv.getv(node, 'lineno'),
}
pos = gv.getv(node, 'pos').split(',')
width = gv.getv(node, 'width')
height = gv.getv(node, 'height')
x, y = map(int, pos)
class_box = ClassBox(props, width, height)
class_box.matrix.translate(x, y)
self.view.canvas.add(class_box)
context[(props['filepath'], props['title'])] = class_box
node = gv.nextnode(g, node)
edge = gv.firstedge(g)
while edge is not None:
props = {
'arrowhead' : gv.getv(edge, 'arrowhead'),
'arrowtail' : gv.getv(edge, 'arrowtail'),
}
head = gv.headof(edge)
tail = gv.tailof(edge)
head_str = (gv.getv(head, 'filepath'), gv.getv(head, 'label'))
tail_str = (gv.getv(tail, 'filepath'), gv.getv(tail, 'label'))
context[head_str]
context[tail_str]
edge = gv.nextedge(g, edge)
set_association(self.view.canvas, context[head_str], \
context[tail_str], props)
def CreateClassDiagram(self):
for delphi in self.documentation:
for delphiClass in delphi.classes:
self.gr.add_nodes([delphiClass.name])
for delphi in self.documentation:
for delphiClass in delphi.classes:
try:
self.gr.add_edge((delphiClass.name, delphiClass.superClass))
except:
print("Edge already exist")
dot = write(self.gr)
gvv = gv.readstring(dot)
gv.layout(gvv,'dot')
gv.render(gvv,'svg','Delphi-Classdiagram.svg')
def testGraph():
gr = graph()
gr.add_nodes([
"Portugal", "Spain", "France", "Germany", "Belgium", "Netherlands",
"Italy"
])
gr.add_nodes([
"Switzerland", "Austria", "Denmark", "Poland", "Czech Republic",
"Slovakia", "Hungary"
])
gr.add_nodes(["England", "Ireland", "Scotland", "Wales"])
gr.add_edge("Portugal", "Spain")
gr.add_edge("Spain", "France")
gr.add_edge("France", "Belgium")
gr.add_edge("France", "Germany")
gr.add_edge("France", "Italy")
gr.add_edge("Belgium", "Netherlands")
gr.add_edge("Germany", "Belgium")
gr.add_edge("Germany", "Netherlands")
gr.add_edge("England", "Wales")
gr.add_edge("England", "Scotland")
gr.add_edge("Scotland", "Wales")
gr.add_edge("Switzerland", "Austria")
gr.add_edge("Switzerland", "Germany")
gr.add_edge("Switzerland", "France")
gr.add_edge("Switzerland", "Italy")
gr.add_edge("Austria", "Germany")
gr.add_edge("Austria", "Italy")
gr.add_edge("Austria", "Czech Republic")
gr.add_edge("Austria", "Slovakia")
gr.add_edge("Austria", "Hungary")
gr.add_edge("Denmark", "Germany")
gr.add_edge("Poland", "Czech Republic")
gr.add_edge("Poland", "Slovakia")
gr.add_edge("Poland", "Germany")
gr.add_edge("Czech Republic", "Slovakia")
gr.add_edge("Czech Republic", "Germany")
gr.add_edge("Slovakia", "Hungary")
# Draw as PNG
with open("./country.viz", 'wb') as f:
dot = write(gr, f)
f.write(dot)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', 'europe.png')
Image.open('europe.png').show()
def output_graph(graph, name, algorithm='neato'):
"""
Output the graph as png image and also as text file
@param name Name of the file to write to
"""
dot = write(graph, True)
gvv = gv.readstring(dot)
name = 'graphs/%s' % name
with open('%s.dot'%name, 'w') as f:
f.write(dot)
gv.layout(gvv, algorithm)
gv.render(gvv, 'png', ('%s.png' % name))
def graphgen(grnodes):
"""Initialises the graph. Ensures that all nodes in the graph are connected.
Creates an image called graph.png which represents the graph.
"""
graph = generate(grnodes, int(1.2*grnodes),
directed=False, weight_range=(1, 1))
# Makes sure graphs generated by generate() have all their nodes connected.
while len(shortest_path(graph, 0)[1]) < grnodes:
graph = generate(grnodes, int(1.2*grnodes),
directed=False, weight_range=(1, 1))
# print len(shortest_path(graph, 0)[1])
# Draw as PNG
dot = write(graph)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', 'graph.png')
return graph
def dep_graph(fn, specs, silent=False):
"""
Create a dependency graph for the given easyconfigs.
"""
# check whether module names are unique
# if so, we can omit versions in the graph
names = set()
for spec in specs:
names.add(spec["module"][0])
omit_versions = len(names) == len(specs)
def mk_node_name(mod):
if omit_versions:
return mod[0]
else:
return "-".join(mod)
# enhance list of specs
for spec in specs:
spec["module"] = mk_node_name(spec["module"])
spec["unresolvedDependencies"] = [
mk_node_name(s) for s in spec["unresolvedDependencies"]
] # [s[0] for s in spec['unresolvedDependencies']]
# build directed graph
dgr = digraph()
dgr.add_nodes([spec["module"] for spec in specs])
for spec in specs:
for dep in spec["unresolvedDependencies"]:
dgr.add_edge((spec["module"], dep))
# write to file
dottxt = dot.write(dgr)
if fn.endswith(".dot"):
# create .dot file
write_file(fn, dottxt)
else:
# try and render graph in specified file format
gvv = gv.readstring(dottxt)
gv.layout(gvv, "dot")
gv.render(gvv, fn.split(".")[-1], fn)
if not silent:
print "Wrote dependency graph for %d easyconfigs to %s" % (len(specs), fn)
def Main():
parser = argparse.ArgumentParser()
parser.add_argument("input_pdf",
type=str,
help="pdf file that will be analysed.")
parser.add_argument("-T",
"--debug-with-token",
action="store_true",
help="print token strings.")
parser.add_argument("-o",
"--output-png",
default="out.png",
help="path to a png file to be written.",
type=str)
args = parser.parse_args()
tk = Tokenizer(args.input_pdf)
queue = deque([tk.token(), tk.token(), tk.token()])
obj_num = ""
attr = ""
gr = digraph()
while not allNone(queue):
if isObjToken(queue):
attr = ""
obj_num = getObjNum(queue)
if not gr.has_node(obj_num):
gr.add_node(obj_num)
elif isIndirect(queue):
if not gr.has_node(getIndirectNum(queue)):
gr.add_node(getIndirectNum(queue))
if not gr.has_edge((obj_num, getIndirectNum(queue))):
#print "obj: " + obj_num + " to: " + getIndirectNum(queue)
gr.add_edge((obj_num, getIndirectNum(queue)), label=attr)
attr = getAttrName(queue, attr)
debug(queue.popleft(), args.debug_with_token)
queue.append(tk.token())
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', args.output_png)
def dep_graph(fn, specs, silent=False):
"""
Create a dependency graph for the given easyconfigs.
"""
# check whether module names are unique
# if so, we can omit versions in the graph
names = set()
for spec in specs:
names.add(spec['module'][0])
omit_versions = len(names) == len(specs)
def mk_node_name(mod):
if omit_versions:
return mod[0]
else:
return '-'.join(mod)
# enhance list of specs
for spec in specs:
spec['module'] = mk_node_name(spec['module'])
spec['unresolvedDependencies'] = [mk_node_name(s) for s in spec['unresolvedDependencies']] # [s[0] for s in spec['unresolvedDependencies']]
# build directed graph
dgr = digraph()
dgr.add_nodes([spec['module'] for spec in specs])
for spec in specs:
for dep in spec['unresolvedDependencies']:
dgr.add_edge((spec['module'], dep))
# write to file
dottxt = dot.write(dgr)
if fn.endswith(".dot"):
# create .dot file
write_file(fn, dottxt)
else:
# try and render graph in specified file format
gvv = gv.readstring(dottxt)
gv.layout(gvv, 'dot')
gv.render(gvv, fn.split('.')[-1], fn)
if not silent:
print "Wrote dependency graph for %d easyconfigs to %s" % (len(specs), fn)
def main(argv):
outputfile = "deps.png"
parser = argparse.ArgumentParser(
description='Find coffeescript dependencies')
parser.add_argument('dirs',
metavar='dir',
nargs='+',
help='directories to process')
parser.add_argument('-o', '--output', help='output file')
parser.add_argument('-t',
action='store_true',
help='show dependencies in text mode')
args = parser.parse_args()
if args.output is not None:
outputfile = args.output
for root, dirs, files in os.walk(args.dirs[0]):
for f in files:
fullpath = os.path.join(root, f)
if os.path.splitext(fullpath)[1] == '.coffee':
if not prune(fullpath):
analyze(fullpath)
for item in deps:
for node in deps[item]:
gr.add_edge((item, "%s.coffee" % (node)))
if args.t:
for item in deps:
print item
for node in deps[item]:
print "\t %s.coffee" % (node)
# Draw as PNG
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', outputfile)
def _init_fw_from_dot_data(self, fw, dot_data, with_qt):
def target_from_node(node):
return node.name.replace("KF5", "")
src_handle = gv.readstring(dot_data)
targets = set()
for node_handle in gvutils.get_node_list(src_handle):
node = gvutils.Node(node_handle)
if node.shape in TARGET_SHAPES and self._want(node):
target = target_from_node(node)
targets.add(target)
fw.add_target(target)
for edge_handle in gvutils.get_edge_list(src_handle):
edge = gvutils.Edge(edge_handle)
target = target_from_node(edge.tail)
if target in targets and self._want(edge.head):
dep_target = target_from_node(edge.head)
fw.add_target_dependency(target, dep_target)
def DepGraph(j):
linestring = open('tmp/deps'+str(j)+'.txt', 'r').read()
lines = linestring.split('\n')
deps = []
for _deps in lines:
ar = _deps.split()
if len(ar) > 0:
deps.append({'from': ar[1].replace(':',''),'to': ar[4].replace(':',''),'vec': ar[6]})
# znajdz wszystkie instrukcje IND i dodaj je tu
# deps.append({'from': '12','to': '12','vec': ''})
# przejrzyj tmp/petit_loop_0.t znajdz wszystkie instrukcje od for
gr = digraph()
for dep in deps:
if not gr.has_node(dep['from']):
gr.add_nodes([dep['from']])
if not gr.has_node(dep['to']):
gr.add_nodes([dep['to']])
for dep in deps:
if not gr.has_edge((dep['from'],dep['to'])):
gr.add_edge((dep['from'],dep['to']))
# Draw as PNG
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv,'dot')
gv.render(gvv,'png','tmp/scc_'+str(j)+'.png')
gv.render(gvv, 'eps', 'tmp/scc_' + str(j) + '.eps')
return gr
def print_graph(gr, file_path, layout='dot'):
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, layout)
format = file_path.split('.')[-1]
gv.render(gvv, format, file_path)
def _RunSingeRule(cls, rule):
"""Runs a Single Rule.
Args:
rule: string: The rule to run.
Return:
(int, string): Returns a tuple of the result status and the rule.
The status is '1' for success, '0' for 'ignore', '-1' for fail.
"""
TermColor.Info('Generating dependencies for %s' %
Utils.RuleDisplayName(rule))
start = time.time()
gr = digraph.digraph()
gr.add_node(rule)
nodes = [rule]
while len(nodes):
node = nodes.pop(0)
# The rule has already been processed. We assume if the node has outgoing
# edges, the we already processed it.
if gr.node_order(node) > 0: continue
# Add the dependencies of the rule to the graph.
if not Rules.LoadRule(node) or not Rules.GetRule(node):
TermColor.Warning(
'Could not load dependency %s for target %s ' %
(Utils.RuleDisplayName(node), Utils.RuleDisplayName(rule)))
return (-1, rule)
node_data = Rules.GetRule(node)
for dep in node_data.get('dep', set()):
nodes += [dep]
# Add the dep to the graph.
if not gr.has_node(dep): gr.add_node(dep)
if not gr.has_edge([node, dep]): gr.add_edge([node, dep])
# Now we have the graph, lets render it.
try:
dt = dot.write(gr)
dt = dt.replace('"%s";' % rule, ('"%s" [style=filled];' % rule), 1)
dt = dt.replace(FileUtils.GetSrcRoot(), '')
depgrah_file_name = cls.__GetDepGraphFileNameForRule(rule)
if Flags.ARGS.mode == 'gv':
gvv = gv.readstring(dt)
gv.layout(gvv, 'dot')
gv.render(gvv, 'pdf', depgrah_file_name)
if not Flags.ARGS.quiet:
subprocess.call('gv %s &' % depgrah_file_name, shell=True)
elif Flags.ARGS.mode == 'text':
FileUtils.CreateFileWithData(depgrah_file_name, dt)
TermColor.Info(
'Generated dependency graph (%d nodes) for %s at %s \tTook %.2fs'
% (len(gr.nodes()), Utils.RuleDisplayName(rule),
depgrah_file_name, (time.time() - start)))
return (1, rule)
except Exception as e:
TermColor.Error('Failed to render %s. Error: %s' %
(Utils.RuleDisplayName(rule), e))
if type(e) == KeyboardInterrupt: raise e
return (-1, rule)
def save_graph(graph, outfile):
dot = write(graph)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', outfile)
def DrawGraph(self, nazwa):
dot = write(self.graph)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', nazwa + '.png')
gv.render(gvv, 'eps', nazwa + '.eps')
def _dep_graph_gv(dottxt, filename):
"""Render dependency graph to file using graphviz."""
# try and render graph in specified file format
gvv = gv.readstring(dottxt)
gv.layout(gvv, 'dot')
gv.render(gvv, os.path.splitext(filename)[-1], filename)
def loads_invalid_obj_list(s):
decoder = JSONDecoder()
objs = [decoder.decode(x) for x in s.split()]
return objs
nodes = loads_invalid_obj_list(sys.stdin.read().strip())
spansBySpanId = {s["SpanID"]: s for s in nodes}
spansByParent = defaultdict(set)
for node in spansBySpanId.values():
spansByParent[node["ParentID"]].add(node["SpanID"])
count = 0
for x in spansByParent[ROOT_SPAN_ID]:
count += 1
gr = digraph()
gr.add_node(
x, [("label", spansBySpanId[x]["Description"] + "(" +
str(spansBySpanId[x]["Stop"] - spansBySpanId[x]["Start"]) + ")")])
buildGraph(x)
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(
gvv, 'png', './graphs/' + str(datetime.now()) +
str(spansBySpanId[x]["Description"])[:10] + '.png')
print("Created " + str(count) + " images.")
def main(argv):
outputfile = argv[0] + ".png"
f = open(argv[0], 'r')
nodes = []
for line in f:
command = line.rstrip()
if command.startswith('#'):
continue
if command is "":
continue
fields = command.split(STYLE_SEPARATOR)
if fields[0].startswith('node'):
# define a new node
# ex.: ['node A', 'dashed']
newnode = fields[0].split(' ')
nodename = newnode[1]
if nodename not in nodes:
nodes.append(nodename)
gr.add_node(newnode[1])
else:
#arrow
edge = fields[0].split(',')
arrow = edge[0]
try:
comment_tmp = fields[1].split(',')
except IndexError:
comment_tmp = ''
try:
arrow_color = edge[1]
except IndexError:
arrow_color = ''
try:
comment = comment_tmp[0]
except IndexError:
comment = ''
try:
comment_color = comment_tmp[1]
except IndexError:
comment_color = arrow_color
attrs = []
attrs.append(('fontcolor', comment_color))
attrs.append(('label', comment))
attrs.append(('color', arrow_color))
if '-->' in arrow:
attrs.append(('style', 'dashed'))
start = arrow.index('-->')
node_from = arrow[0:start]
node_to = arrow[start + 3:]
create_arrow(node_from, node_to, attrs, nodes)
elif '->' in arrow and '-->' not in arrow:
attrs.append(('style', ''))
start = arrow.index('->')
node_from = arrow[0:start]
node_to = arrow[start + 2:]
create_arrow(node_from, node_to, attrs, nodes)
elif '..>' in arrow:
attrs.append(('style', 'dotted'))
start = arrow.index('..>')
node_from = arrow[0:start]
node_to = arrow[start + 3:]
create_arrow(node_from, node_to, attrs, nodes)
# Draw as PNG
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png', outputfile)
def bgp_graph_gen(graphdata, start=None, end=None):
gr = digraph()
def transform_nodename(name):
return name.replace(":", "")
def transform_label(s):
return "".join(["&#%d;" % ord(x) for x in s])
def add_node(graph, v, fillcolor=None, shape='ellipse'):
vid = transform_nodename(v)
if (not graph.has_node(vid)):
params = [('fontsize', FONT_SIZE), ('shape', shape),
('label', transform_label(v))]
if (fillcolor):
params = params + [('style', 'filled'),
('fillcolor', fillcolor)]
graph.add_node(vid, attrs=params)
def add_edge(graph,
v1,
v2,
color='black',
style='solid',
penwidth=REC_LINE_WIDTH,
label=None):
if (v1 == v2):
return
vid1 = transform_nodename(v1)
vid2 = transform_nodename(v2)
if (not graph.has_edge((vid1, vid2))):
params = [('color', color), ('style', style),
('penwidth', penwidth)]
if (label):
params = params + [
('fontsize', LABEL_FONT_SIZE),
('label', transform_label(" " + label + " "))
]
graph.add_edge((vid1, vid2), attrs=params)
for gd in graphdata:
if (start):
add_node(gr, start, shape='box', fillcolor=USED_FILL_COLOR)
add_node(gr, gd[0][0], fillcolor=USED_FILL_COLOR)
add_edge(gr,
start,
gd[0][0],
color=USED_LINE_COLOR,
penwidth=USED_LINE_WIDTH,
style='dashed')
vparams = {}
eparams = {}
if (gd[1]['recuse']):
eparams['color'] = USED_LINE_COLOR
eparams['penwidth'] = USED_LINE_WIDTH
vparams['fillcolor'] = USED_FILL_COLOR
elif (gd[1]['reconly']):
eparams['color'] = RECONLY_LINE_COLOR
eparams['style'] = 'dotted'
eparams['penwidth'] = REC_LINE_WIDTH
else:
eparams['penwidth'] = REC_LINE_WIDTH
eparams['color'] = REC_LINE_COLOR
i = 0
while (i < len(gd[0])):
if (i + 1 < len(gd[0])):
add_node(gr, gd[0][i], **vparams)
add_node(gr, gd[0][i + 1], **vparams)
if ((i == 0) and ('peer' in gd[1])):
add_edge(gr,
gd[0][i],
gd[0][i + 1],
label=gd[1]['peer'],
**eparams)
else:
add_edge(gr, gd[0][i], gd[0][i + 1], **eparams)
i = i + 1
if (end):
add_node(gr, end, shape='box', fillcolor=USED_FILL_COLOR)
add_edge(gr,
gd[0][-1],
end,
color=USED_LINE_COLOR,
penwidth=USED_LINE_WIDTH,
style='dashed')
dot = write(gr)
gvv = gv.readstring(dot)
gv.layout(gvv, 'dot')
gv.render(gvv, 'png')
#!/usr/bin/python
import gv
g = gv.digraph("G")
print gv.setv(g, "aaa", "xxx")
print gv.getv(g, "aaa")
n = gv.node(g, "hello")
print gv.getv(n, "label")
print gv.setv(n, "aaa", "xxx")
print gv.getv(n, "aaa")
m = gv.node(g, "world")
print gv.getv(m, "aaa")
e = gv.edge(n, m)
print gv.setv(e, "aaa", "xxx")
print gv.getv(e, "aaa")
gv.rm(e)
gv.rm(m)
gv.rm(n)
gv.rm(g)
g = gv.readstring("digraph G {a->b}")
gv.rm(g)
g = gv.read("hello.gv")
gv.layout(g, "dot")
gv.render(g, "png", "hello.png")
gv.rm(g)
