def gen_dot():
d = Dot()
nodes = dict()
login = read_ssv_file("vpopmail.login")
db = MySQLdb.connect(host="localhost", user=login[0], passwd=login[2], db=login[1])
c = db.cursor()
c.execute("SELECT alias, valias_line FROM valias WHERE domain=%s", (MAILDOMAIN,))
for alias, target in c.fetchall():
assert target[0] == "&"
target = target[1:]
alias += "@" + MAILDOMAIN
if not alias in nodes:
nodes[alias] = Node(alias)
d.add_node(nodes[alias])
if not target in nodes:
nodes[target] = Node(target)
d.add_node(nodes[target])
d.add_edge(Edge(nodes[alias], nodes[target]))
for list in Utils.list_names():
if list == "plukdenacht2008":
continue
source = list + "@" + LISTDOMAIN
if not source in nodes:
nodes[source] = Node(source)
d.add_node(nodes[source])
m = MailList.MailList(list, lock=False)
for member in m.members:
if not member in nodes:
nodes[member] = Node(member)
d.add_node(nodes[member])
d.add_edge(Edge(nodes[source], nodes[member]))
d.write("the.dot")
def save(self, cfg, filename, print_ir=False, format='dot', options=None):
"""Save basic block graph into a file.
"""
if options is None:
options = {}
try:
dot_graph = Dot(**self.graph_format)
# Add nodes.
nodes = {}
for bb in cfg.basic_blocks:
nodes[bb.address] = self._create_node(bb, cfg.name, print_ir,
options)
dot_graph.add_node(nodes[bb.address])
# Add edges.
for bb_src in cfg.basic_blocks:
for bb_dst_addr, branch_type in bb_src.branches:
edge = self._create_edge(nodes[bb_src.address],
nodes[bb_dst_addr], branch_type)
dot_graph.add_edge(edge)
# Save graph.
dot_graph.write("{}.{}".format(filename, format), format=format)
except Exception:
logger.error("Failed to save basic block graph: %s (%s)",
filename,
format,
exc_info=True)
def plot_state(self, boxes, deltas, name = '', outdir = None):
""" Make a graph of a given state """
graph = Dot(graph_type='digraph', fontname="Verdana", size="10, 5", fixedsize= True)
i_box = 0
for box in boxes:
textcolor = 'white' if sum( [ self.color_chars.index(col) for col in self.plots_conf[box]['color'].split('#')[1] ] ) < 35 else 'black'
node_box = Node(box, style="filled", label = '<<font POINT-SIZE="10" color="'+textcolor+'">'+box+'<br/> '+
"%.7f" % round(deltas[i_box], 7)+'</font>>',
fillcolor = self.plots_conf[box]['color'], shape = self.plots_conf[box]['shape'])
i_box += 1
graph.add_node(node_box)
for box_from, boxes_to in self.Flux.iteritems():
for box_to, flux in boxes_to.iteritems():
if flux !=0:
if flux > 0:
edge = Edge(box_from, box_to, label = '<<font POINT-SIZE="10">'+str(flux)+'</font>>')
elif flux < 0:
edge = Edge(box_to, box_from, label = '<<font POINT-SIZE="10">'+str(flux)+'</font>>')
graph.add_edge(edge)
if outdir is None:
outdir = self.result_dir
outfile = outdir+'/state'+name+'.png'
graph.write_png(outfile)
logger.info('State has been saved to '+set_style(outfile, 'emph'))
def save(self, cf, filename, format='dot'):
"""Save basic block graph into a file.
"""
try:
dot_graph = Dot(**self.graph_format)
# add nodes
nodes = {}
for cfg_addr in cf._graph.node.keys():
nodes[cfg_addr] = self._create_node(cfg_addr, cf)
dot_graph.add_node(nodes[cfg_addr])
# add edges
for cfg_src_addr in cf._graph.node.keys():
for cfg_dst_addr in cf._edges.get(cfg_src_addr, []):
edge = self._create_edge(nodes, cfg_src_addr, cfg_dst_addr)
dot_graph.add_edge(edge)
dot_graph.write("{}.{}".format(filename, format), format=format)
except Exception as err:
logger.error("Failed to save call graph: %s (%s)",
filename,
format,
exc_info=True)
def _plot_tree(self,
graph: pydot.Dot,
tree: Dict,
parent_node=None) -> None:
for k in tree:
if parent_node is not None:
from_name = parent_node.get_name().replace("\"",
"") + '_' + str(k)
from_label = str(k)
node_from = pydot.Node(from_name, label=from_label)
graph.add_node(node_from)
graph.add_edge(pydot.Edge(parent_node, node_from))
if isinstance(tree[k], dict):
self._plot_tree(graph, tree[k], node_from)
else: # if leaf node
to_name = str(k) + '_' + str(tree[k]) # unique name
to_label = str(tree[k])
node_to = pydot.Node(to_name, label=to_label, shape='box')
graph.add_node(node_to)
graph.add_edge(pydot.Edge(node_from, node_to))
else:
from_name = str(k)
from_label = str(k)
node_from = pydot.Node(from_name, label=from_label)
graph.add_node(node_from)
self._plot_tree(graph, tree[k], node_from)
def graphFromList(edge_list, node_prefix='', directed=True):
"""Creates a basic graph out of an edge list.
The edge list has to be a list of tuples representing
the nodes connected by the edge.
The values can be anything: bool, int, float, str.
If the graph is undirected by default, it is only
calculated from one of the symmetric halves of the matrix.
If the graph has weighted edges, edge_list will be of the
form:
[ (vert1, vert2, weight), ... ]
else:
[ (vert1, vert2), ... ]
"""
weighted = len(edge_list[0]) % 2
if directed:
graph = Dot(graph_type='digraph')
else:
graph = Dot(graph_type='graph')
for edge in edge_list:
e = Edge(node_prefix+str(edge[0]), node_prefix+str(edge[1]))
if weighted:
e.label = e.weight = edge[2]
graph.add_edge(e)
return graph
def handle(self, filename=None, **options):
try:
from pydot import Dot, Edge, Node
except ImportError:
raise CommandError("need pydot python module ( apt-get install python-pydot )")
graph = Dot()
for status, description in STATUS_CHOICES:
graph.add_node(Node(
'status-%s' % status,
label='"%s (%s)"' %
(description.encode('utf-8'), status))
)
from sadiki.core.workflow import workflow
for transition_index in workflow.available_transitions():
transition = workflow.get_transition_by_index(transition_index)
graph.add_edge(Edge(
'status-%s'% transition.src,
'status-%s' % transition.dst,
label='"%s (%s)"' % (transition.comment.encode('utf-8'), transition.index),
style='solid' if transition.required_permissions else 'dashed',
))
if filename:
graph.write_png(filename)
else:
print graph.to_string()
def create_example_graph():
g = Dot(graph_name="workflow: example",
labelloc="t", label="workflow: example", fontsize=18, fontcolor="blue")
g.set_node_defaults(shape="box", fontsize=12)
g.set_edge_defaults(fontsize=13, labeldistance=3)
n1 = Node(name="Start")
g.add_node(n1)
n2 = Node(name="StepTrueEnd", color="#04B45F")
g.add_node(n2)
n3 = Node(name="StepFalse")
g.add_node(n3)
n4 = Node(name="StepFalse2")
g.add_node(n4)
n5 = Node(name="StepFalse3End", color="#04B45F")
g.add_node(n5)
e1 = true_edge(n1, n2)
g.add_edge(e1)
e2 = false_edge(n1, n3)
g.add_edge(e2)
e3 = true_edge(n3, n4)
g.add_edge(e3)
e_back = false_edge(n4, n1, label="back if false")
g.add_edge(e_back)
e4 = true_edge(n4, n5)
g.add_edge(e4)
return g
def draw(self):
dt = Dot(graph_type='digraph',fontname="Verdana")
for node in self.nodes:
dt.add_node(pydot.Node(node.name, label=self.simplabel(node)))
for edge in self.edges:
dt.add_edge(pydot.Edge(edge.frm.name, edge.to.name))
return dt
def visualize(self, filename):
"""Save a graphical representation of this AF."""
graph = Dot(graph_type='digraph')
for arg in self.args:
text = arg.text
# Add any offers to the text that this argument may support
for off, supp in self.supp_args.items():
if arg in supp:
text += f"\n[{off}]"
graph.add_node(Node(name=text))
for att in self.attacks:
texts = []
for arg in [att.arg_start, att.arg_end]:
texts.append(arg.text)
for off, supp in self.supp_args.items():
if arg in supp:
texts[-1] += f"\n[{off}]"
if att.arg_start not in self.args or \
att.arg_end not in self.args:
print(f"Warning: attack in AF but not its start or end")
graph.add_edge(Edge(texts[0], texts[1], dirType="forward"))
graph.write_png(filename)
def gen_dot():
d = Dot()
nodes = dict()
login = read_ssv_file('vpopmail.login')
db = MySQLdb.connect(host='localhost',
user=login[0],
passwd=login[2],
db=login[1])
c = db.cursor()
c.execute("SELECT alias, valias_line FROM valias WHERE domain=%s",
(MAILDOMAIN, ))
for alias, target in c.fetchall():
assert target[0] == '&'
target = target[1:]
alias += "@" + MAILDOMAIN
if not alias in nodes:
nodes[alias] = Node(alias)
d.add_node(nodes[alias])
if not target in nodes:
nodes[target] = Node(target)
d.add_node(nodes[target])
d.add_edge(Edge(nodes[alias], nodes[target]))
for list in Utils.list_names():
if list == 'plukdenacht2008': continue
source = list + "@" + LISTDOMAIN
if not source in nodes:
nodes[source] = Node(source)
d.add_node(nodes[source])
m = MailList.MailList(list, lock=False)
for member in m.members:
if not member in nodes:
nodes[member] = Node(member)
d.add_node(nodes[member])
d.add_edge(Edge(nodes[source], nodes[member]))
d.write('the.dot')
def _add_edge(self, progenitor: pydot.Dot, op: Union[Trace, Op],
label_last_seen: Dict[str, str], ds_id: Optional[str]):
"""Draw edges into a given Node.
Args:
progenitor: The very top level diagram onto which Edges should be written.
op: The op (or trace) to be visualized.
label_last_seen: A mapping of {data_dict_key: node_id} indicating the last node which generated the key.
ds_id: The ds_id under which the node is currently running.
"""
node_id = str(id(op))
edge_srcs = defaultdict(lambda: [])
global_ds_ids = {
key
for vals in self.system.pipeline.data.values()
for key in vals.keys() if key is not None
}
for inp in label_last_seen.keys() if isinstance(op,
Batch) else op.inputs:
if inp == '*':
continue
_, candidate_id, *_ = f"{inp}|".split('|')
if candidate_id in global_ds_ids and candidate_id != ds_id:
continue # Skip inputs which will be provided in other ds_id plots
edge_srcs[label_last_seen[inp]].append(inp)
for src, labels in edge_srcs.items():
progenitor.add_edge(
pydot.Edge(src=src,
dst=node_id,
label=f" {', '.join(labels)} "))
outputs = op.get_outputs(
ds_ids=ds_id) if isinstance(op, Trace) else op.outputs
for out in label_last_seen.keys() if isinstance(op,
Batch) else outputs:
label_last_seen[out] = node_id
def save(self, cfg, filename, print_ir=False, format='dot', options=None):
"""Save basic block graph into a file.
"""
if options is None:
options = {}
try:
dot_graph = Dot(**self.graph_format)
# Add nodes.
nodes = {}
for bb in cfg.basic_blocks:
nodes[bb.address] = self._create_node(bb, cfg.name, print_ir, options)
dot_graph.add_node(nodes[bb.address])
# Add edges.
for bb_src in cfg.basic_blocks:
for bb_dst_addr, branch_type in bb_src.branches:
edge = self._create_edge(nodes[bb_src.address], nodes[bb_dst_addr], branch_type)
dot_graph.add_edge(edge)
# Save graph.
dot_graph.write("{}.{}".format(filename, format), format=format)
except Exception:
logger.error("Failed to save basic block graph: %s (%s)", filename, format, exc_info=True)
def get_session_svg(viz_data):
"""Take session visualization data and return svg."""
graph = Dot('graphname', graph_type='digraph')
#loop create all nodes and store by id
node_dict = {}
for i, node_data in enumerate(viz_data['nodes']):
id = node_data['id']
node_dict[id] = str(i)
graph.add_node(Node(str(i)))
#add edges by links
for link_data in viz_data['links']:
snode = node_dict[viz_data['nodes'][link_data['source']]['id']]
tnode = node_dict[viz_data['nodes'][link_data['target']]['id']]
graph.add_edge(Edge(snode, tnode))
#get svg of graph
file = NamedTemporaryFile()
graph.write_svg(file.name)
svg = file.read()
file.close()
#f = open('/tmp/session/session.svg', 'w')
#f.write("%s\n" % svg)
#f.close()
return svg
def create_example_graph():
g = Dot(graph_name="workflow: example",
labelloc="t",
label="workflow: example",
fontsize=18,
fontcolor="blue")
g.set_node_defaults(shape="box", fontsize=12)
g.set_edge_defaults(fontsize=13, labeldistance=3)
n1 = Node(name="Start")
g.add_node(n1)
n2 = Node(name="StepTrueEnd", color="#04B45F")
g.add_node(n2)
n3 = Node(name="StepFalse")
g.add_node(n3)
n4 = Node(name="StepFalse2")
g.add_node(n4)
n5 = Node(name="StepFalse3End", color="#04B45F")
g.add_node(n5)
e1 = true_edge(n1, n2)
g.add_edge(e1)
e2 = false_edge(n1, n3)
g.add_edge(e2)
e3 = true_edge(n3, n4)
g.add_edge(e3)
e_back = false_edge(n4, n1, label="back if false")
g.add_edge(e_back)
e4 = true_edge(n4, n5)
g.add_edge(e4)
return g
def get_session_svg(viz_data):
"""Take session visualization data and return svg."""
graph = Dot('graphname', graph_type='digraph')
#loop create all nodes and store by id
node_dict = {}
for i, node_data in enumerate(viz_data['nodes']):
id = node_data['id']
node_dict[id] = str(i)
graph.add_node(Node(str(i)))
#add edges by links
for link_data in viz_data['links']:
snode = node_dict[viz_data['nodes'][link_data['source']]['id']]
tnode = node_dict[viz_data['nodes'][link_data['target']]['id']]
graph.add_edge(Edge(snode, tnode))
#get svg of graph
file = NamedTemporaryFile()
graph.write_svg(file.name)
svg = file.read()
file.close()
#f = open('/tmp/session/session.svg', 'w')
#f.write("%s\n" % svg)
#f.close()
return svg
def show_diagram(self, path=None):
"""
Creates the graph associated with this DFA
"""
# Nodes are set of states
graph = Dot(graph_type='digraph', rankdir='LR')
nodes = {}
for state in self.states:
if state == self.initial_state:
# color start state with green
initial_state_node = Node(
state, style="filled", fillcolor="green")
nodes[state] = initial_state_node
graph.add_node(initial_state_node)
else:
state_node = Node(state)
nodes[state] = state_node
graph.add_node(state_node)
# adding edges
for from_state, lookup in self.transitions.items():
for to_label, to_state in lookup.items():
graph.add_edge(Edge(
nodes[from_state],
nodes[to_state],
label=to_label
))
if path:
graph.write_png(path)
return graph
def write(self, filename, format="png", append_ext=False, prog="dot"):
"Builds a pydot graph and writes to file"
from pydot import Dot, Edge, Node
dot = Dot(graph_type='digraph', **self.graph_attributes)
if format not in dot.formats:
raise GraphException("invalid format '%s'" % format)
node_cache = {}
def get_node(s):
try:
return node_cache[s]
except KeyError:
node = Node(s, **self.node_attributes.get(s, {}))
dot.add_node(node)
node_cache[s] = node
return node
for (s0, s1), attr in self.edge_attributes.iteritems():
dot.add_edge(Edge(get_node(s0), get_node(s1),
**self.edge_attributes.get((s0, s1), {})))
for node in self.get_orphaned_nodes():
get_node(node)
if append_ext:
filename = "%s.%s" % (filename, format)
dot.write(filename, format=format, prog=prog)
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 process_plan(filename,
plan,
names=True,
with_dist=False,
with_label=False):
graph = Dot(overlap="false", splines="true", esep=.2)
teams = fetch_teams()
distances = fetch_distances()
nodes = make_nodes(plan, teams, names)
for team_node in nodes:
graph.add_node(nodes[team_node])
for team in plan:
edges = graph_way(team, plan[team], nodes, distances, with_dist,
with_label)
for edge in edges:
graph.add_edge(edge)
if with_dist:
graph.write_png(filename, prog="neato")
else:
graph.write_png(filename, prog="dot")
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 save(self, filename, print_ir=False, format='dot'):
"""Save basic block graph into a file.
"""
node_format = {
'shape' : 'Mrecord',
'rankdir' : 'LR',
'fontname' : 'monospace',
'fontsize' : '9.0'
}
edge_format = {
'fontname' : 'monospace',
'fontsize' : '8.0'
}
edge_colors = {
'taken' : 'green',
'not-taken' : 'red',
'direct' : 'blue'
}
try:
# for each conneted component
for idx, gr in enumerate(networkx.connected_component_subgraphs(self._graph.to_undirected())):
graph = Dot(graph_type="digraph", rankdir="TB")
# add nodes
nodes = {}
for bb_addr in gr.node.keys():
dump = self._dump_bb(self._bb_by_addr[bb_addr], print_ir)
# html-encode colon character
dump = dump.replace("!", "!")
dump = dump.replace("#", "#")
dump = dump.replace(":", ":")
dump = dump.replace("{", "{")
dump = dump.replace("}", "}")
label = "{<f0> 0x%08x | %s}" % (bb_addr, dump)
nodes[bb_addr] = Node(bb_addr, label=label, **node_format)
graph.add_node(nodes[bb_addr])
# add edges
for bb_src_addr in gr.node.keys():
for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches:
graph.add_edge(Edge(nodes[bb_src_addr],
nodes[bb_dst_addr], label=branch_type, \
color=edge_colors[branch_type], **edge_format))
graph.write("%s_%03d.%s" % (filename, idx, format), format=format)
except Exception as err:
import traceback
import sys
print("[E] Error loading BARF (%s:%d) : '%s'" %
(__name__, sys.exc_traceback.tb_lineno, str(err)))
print("")
print(traceback.format_exc())
def buildDependencyControlGraph(dependencies,sizes=[1,2],productionTarget=1.25):
from pydot import Dot, Node, Edge, Cluster
dgraph = Dot(graph_type='graph',fontname='Verdana',splines="line",maxiter="500")
#splines="line",
nodes = {}
edges = {}
for (controlMap,pvalue) in dependencies:
targetNames = []
size = len(controlMap)
if size not in sizes:
continue
for (targetName,cvalue) in controlMap.items():
#targetTag = "%s(%s)" % (targetName,cvalue)
targetTag = targetName
targetNames.append(targetTag)
if size not in nodes.keys():
nodes[size] = set()
nodes[size].add((targetName,cvalue))
edgeCombos = combinations(targetNames,2)
for value in edgeCombos:
key = list(value)
key.sort()
(e1,e2) = key
if (e1,e2) not in edges.keys() and (e2,e1) not in edges.keys():
edge = Edge(e1,e2)
edges[(e1,e2)] = edge
else:
#print "dup key %s %s" % (e1,e2)
pass
nodes = cleanNodeNames(nodes)
for (key,nodeValues) in nodes.items():
if key == 1:
ishape = "rectangle"
elif key == 2:
ishape = "oval"
elif key == 3:
ishape = "hexagon"
else:
ishape = "circle"
for (name,value) in nodeValues:
icolor = "black"
if value > 0:
icolor = "red"
if value < 0:
icolor = "green"
targetTag = "%s(%s)" % (name,value)
targetTag = name
dgraph.add_node(Node(targetTag,shape=ishape,color=icolor))
#print "Node: [%s] : size[%s] value[%s] shape[%s]" % (name,key,value,ishape)
for (key,edge) in edges.items():
dgraph.add_edge(edge)
return dgraph
class DotGraph:
def __init__(self, functions):
self.node_dic = {}
self.edge_dic = {}
self.graph = Dot()
self.html = None
for f in functions:
if f.name in [
'slitherConstructorVariables',
'slitherConstructorConstantVariables'
]:
continue
self.construct_node(f)
self.construct_graph(functions)
self.html = svg_to_html(self.graph.create_svg().decode('utf-8'))
def construct_node(self, function):
n = Node(function.name)
n.set_tooltip(construct_tooltip(function))
self.node_dic[function.name] = n
self.graph.add_node(n)
def construct_graph(self, functions):
for f in functions:
if (f.name in [
'slitherConstructorVariables',
'slitherConstructorConstantVariables'
] or f.slither_function.is_constructor):
continue
for sr in f.read:
for written_f in sr.written_by:
if written_f.name not in [
'slitherConstructorVariables',
'slitherConstructorConstantVariables'
]:
n1 = self.get_node(f.name)
n2 = self.get_node(written_f.name)
if self.edge_dic.get((n1, n2)):
e = self.edge_dic[(n1, n2)]
old_label = e.get_label()
e.set_label(
f'{old_label.strip()}, {sr.name} ')
else:
self.construct_edge(n1, n2)
e = self.edge_dic[(n1, n2)]
e.set_label(f'{sr.name} ')
def construct_edge(self, _n1: Node, _n2: Node):
e = Edge(_n1, _n2, fontsize="8", fontcolor="#2E86C1", arrowsize="0.7")
self.edge_dic[(_n1, _n2)] = e
self.graph.add_edge(e)
def get_node(self, _name):
return self.node_dic.get(_name)
def save(self, filename, print_ir=False, format='dot'):
"""Save basic block graph into a file.
"""
node_format = {
'shape': 'Mrecord',
'rankdir': 'LR',
'fontname': 'monospace',
'fontsize': '9.0'
}
edge_format = {'fontname': 'monospace', 'fontsize': '8.0'}
edge_colors = {'taken': 'green', 'not-taken': 'red', 'direct': 'blue'}
try:
# for each conneted component
for idx, gr in enumerate(
networkx.connected_component_subgraphs(
self._graph.to_undirected())):
graph = Dot(graph_type="digraph", rankdir="TB")
# add nodes
nodes = {}
for bb_addr in gr.node.keys():
dump = self._dump_bb(self._bb_by_addr[bb_addr], print_ir)
# html-encode colon character
dump = dump.replace("!", "!")
dump = dump.replace("#", "#")
dump = dump.replace(":", ":")
dump = dump.replace("{", "{")
dump = dump.replace("}", "}")
label = "{<f0> 0x%08x | %s}" % (bb_addr, dump)
nodes[bb_addr] = Node(bb_addr, label=label, **node_format)
graph.add_node(nodes[bb_addr])
# add edges
for bb_src_addr in gr.node.keys():
for bb_dst_addr, branch_type in self._bb_by_addr[
bb_src_addr].branches:
graph.add_edge(Edge(nodes[bb_src_addr],
nodes[bb_dst_addr], label=branch_type, \
color=edge_colors[branch_type], **edge_format))
graph.write("%s_%03d.%s" % (filename, idx, format),
format=format)
except Exception as err:
import traceback
import sys
print("[E] Error loading BARF (%s:%d) : '%s'" %
(__name__, sys.exc_traceback.tb_lineno, str(err)))
print("")
print(traceback.format_exc())
def graph(self, model_classes):
graph = Dot(**self.graph_options)
relations = set()
# Create nodes from mappers
mappers = list(map(class_mapper, model_classes))
for mapper in mappers:
graph.add_node(
Node(
self.quote(mapper),
label=self.node_table(
mapper.class_.__name__,
self._model_columns(mapper),
self._model_operations(mapper),
),
**self.style["node"],
)
)
if mapper.inherits:
graph.add_edge(
Edge(
*map(self.quote, (mapper.inherits, mapper)),
**self.style["inheritance"],
)
)
for loader in mapper.iterate_properties:
if (
isinstance(loader, RelationshipProperty)
and loader.mapper in mappers
):
reverse = getattr(loader, "_reverse_property")
if len(reverse) == 1:
relations.add(frozenset((loader, next(iter(reverse)))))
else:
relations.add((loader,))
# Create edges from relationships between mappers
for relation in relations:
options = self.style["relationship"].copy()
if len(relation) == 2:
src, dest = relation
if src.viewonly and dest.viewonly:
options.update(self.style["relationship-viewonly"])
between = src.parent, dest.parent
options["headlabel"] = self._format_relationship(src)
options["taillabel"] = self._format_relationship(dest)
options["dir"] = "both"
else:
(prop,) = relation
between = prop.parent, prop.mapper
options["headlabel"] = self._format_relationship(prop)
if prop.viewonly:
options.update(self.style["relationship-viewonly"])
graph.add_edge(Edge(*map(self.quote, between), **options))
return graph
def markBrokenRelations(self):
""" Construct graph and return message with info about broken
relations for ContentTypeGraph if any errors are found
"""
bad_relations = []
bad_content = []
name = self.context.getId()
node = queryAdapter(self.context, INode)
graph = PyGraph()
graph.add_node(node())
tool = queryAdapter(self.context, IToolAccessor)
relations = tool.relations(proxy=False)
for relation in relations:
field = relation.getField('to')
value_from = field.getAccessor(relation)()
field = relation.getField('from')
value_to = field.getAccessor(relation)()
if name == value_from:
nto = self.pt_relations.get(value_to)
if not (value_from == value_to
) and nto:
node = queryAdapter(nto, INode)
graph.add_node(node())
edge = queryAdapter(relation, IEdge)
res = edge()
if res:
graph.add_edge(res)
else:
if value_to not in bad_content:
bad_content.append(value_to)
bad_relations.append(relation.Title())
# if we don't continue when value_from == name
# then we will get a double "node-myX" -> "node-myX"
# graph entry when value_to is also equal to name
continue
if name == value_to:
nfrom = self.pt_relations.get(value_from)
if not (value_from == value_to
) and nfrom:
node = queryAdapter(nfrom, INode)
graph.add_node(node())
edge = queryAdapter(relation, IEdge)
res = edge()
if res:
graph.add_edge(res)
else:
if value_from not in bad_content:
bad_content.append(value_from)
bad_relations.append(relation.Title())
self.graph_res = graph
if bad_relations:
return self.brokenRelationMessage(bad_content, bad_relations)
return ""
def render_graph(root, hierarchy, args):
g = Dot()
g.set_root(root[0])
for manager in hierarchy:
g.add_node(Node(manager[0], shape='box'))
for subordinate in hierarchy[manager]:
g.add_node(Node(subordinate[0], shape='box'))
g.add_edge(Edge(manager[0], subordinate[0]))
g.write_svg(args.file, args.imageType, args.layout)
class PydotAstWalker(object):
def __init__(self, ast_root, course_code, valid_expr=True):
self.course_code = course_code
self.valid_expr = valid_expr
self.ast = ast_root
self.graph = Dot(graph_type='digraph')
def _name_node(self, node):
if node.is_course():
# what if not leaf node?
return node.code
elif node.is_operator():
name = str(node)
for child in node.children:
name += self._name_node(child)
return name
def generate_graph(self):
course_root_node = Node(self.course_code, style="filled", colorscheme="set35", fillcolor="5")
if not self.ast:
if not self.valid_expr:
return Node(self.course_code, style="filled", colorscheme="set35", fillcolor="4")
else:
return course_root_node
edges = set()
root_operator_node = self._visit_node(self.ast, edges)
for edge in edges:
self.graph.add_edge(edge.to_pydot_edge())
self.graph.add_node(course_root_node)
self.graph.add_edge(Edge(course_root_node, root_operator_node))
return self.graph
def _visit_node(self, ast_node, edges):
if ast_node.is_course():
node = Node(ast_node.code, style="filled", colorscheme="set35", fillcolor="2")
self.graph.add_node(node)
if not ast_node.is_leaf():
child = self._visit_node(ast_node.child, edges)
edge = UniqueEdge(node, child)
edges.add(edge)
return node
elif ast_node.is_operator():
name = self._name_node(ast_node)
if isinstance(ast_node, AllOf):
this_node = Node(name, label=str(ast_node), shape="square", style="filled", colorscheme="set35", fillcolor="3")
else:
this_node = Node(name, label=str(ast_node), shape="diamond", style="filled", colorscheme="set35", fillcolor="1")
self.graph.add_node(this_node)
child_nodes = [self._visit_node(child, edges) for child in ast_node.children]
for child in child_nodes:
edge = UniqueEdge(this_node, child)
edges.add(edge)
return this_node
def as_dot(self, name='Model'):
graph = DotGraph(graph_name=name, graph_type='digraph')
for node in self.nodes:
dot_node = node.as_dot()
graph.add_node(dot_node)
for arc in node.outgoing_arcs:
graph.add_edge(
Edge(dot_node,
arc.target.as_dot(),
label=arc.label.__name__))
return graph
def visualize(graph, filename="graph.png", include_args=True, transitive=False):
data = to_graphviz(graph, transitive)
dot = Dot(graph_type="digraph")
for node in data["nodes"]:
fmt = format_edge(graph, node) if include_args else node
dot.add_node(Node(node, label=fmt))
for a, b in data["edges"]:
dot.add_edge(Edge(a, b))
dot.write_png(filename)
def RenderSIPCollection(sipGraph, dot=None):
try:
from pydot import Node, Edge, Dot
except:
import warnings
warnings.warn("Missing pydot library", ImportWarning)
if not dot:
dot = Dot(graph_type='digraph')
dot.leftNodesLookup = {}
nodes = {}
for N, prop, q in sipGraph.query(
'SELECT ?N ?prop ?q { ?prop a magic:SipArc . ?N ?prop ?q . }',
initNs={u'magic': MAGIC}):
if MAGIC.BoundHeadPredicate in sipGraph.objects(
subject=N, predicate=RDF.type):
NCol = [N]
else:
NCol = Collection(sipGraph, N)
if q not in nodes:
newNode = Node(makeMD5Digest(q),
label=normalizeTerm(q, sipGraph),
shape='plaintext')
nodes[q] = newNode
dot.add_node(newNode)
bNode = BNode()
nodeLabel = ', '.join([normalizeTerm(term, sipGraph)
for term in NCol])
edgeLabel = ', '.join([var.n3()
for var in Collection(sipGraph,
first(sipGraph.objects(
prop, MAGIC.bindings)))])
markedEdgeLabel = ''
if nodeLabel in dot.leftNodesLookup:
bNode, leftNode, markedEdgeLabel = dot.leftNodesLookup[nodeLabel]
# print("\t", nodeLabel, edgeLabel,
# markedEdgeLabel, not edgeLabel == markedEdgeLabel
else:
leftNode = Node(makeMD5Digest(bNode),
label=nodeLabel, shape='plaintext')
dot.leftNodesLookup[nodeLabel] = (bNode, leftNode, edgeLabel)
nodes[bNode] = leftNode
dot.add_node(leftNode)
if not edgeLabel == markedEdgeLabel:
edge = Edge(leftNode,
nodes[q],
label=edgeLabel)
dot.add_edge(edge)
return dot
def make_pydot_graph(self, figname='tree'):
''' Use Graphviz to generate a graphical representation of the tree.
Args:
figname (str): where to store the figure.
'''
graph = Dot(graph_type='graph')
#graph.add_node(Node(self.root.display(),shape='diamond'))
edgelist = self.root.append_edgelist()
for edge in edgelist:
graph.add_node(edge[0])
graph.add_node(edge[1])
graph.add_edge(Edge(*edge))
graph.write_png(figname + '.png')
class ContentTypeGraph(BaseGraph):
""" Draw a graph for ContentType
"""
@property
def graph(self):
""" Construct graph and mark broken relations if any
"""
if self._graph is not None:
return self._graph
self._graph = PyGraph()
# This node
name = self.context.getId()
node = queryAdapter(self.context, INode)
self._graph.add_node(node())
xtool = queryAdapter(self.context, IToolAccessor)
for relation in xtool.relations(proxy=False):
field = relation.getField('to')
value_from = field.getAccessor(relation)()
field = relation.getField('from')
value_to = field.getAccessor(relation)()
if name == value_from:
nto = self.tool.get(value_to)
if (value_from != value_to) and nto:
node = queryAdapter(nto, INode)
self._graph.add_node(node())
edge = queryAdapter(relation, IEdge)()
if edge:
self._graph.add_edge(edge)
else:
self._bad_content.add(value_to)
self._bad_relations.add(relation.Title())
elif name == value_to:
nfrom = self.tool.get(value_from)
if (value_from != value_to) and nfrom:
node = queryAdapter(nfrom, INode)
self._graph.add_node(node())
edge = queryAdapter(relation, IEdge)()
if edge:
self._graph.add_edge(edge)
else:
self._bad_content.add(value_from)
self._bad_relations.add(relation.Title())
return self._graph
def RenderSIPCollection(sipGraph, dot=None):
try:
from pydot import Node, Edge, Dot
except:
import warnings
warnings.warn("Missing pydot library", ImportWarning)
if not dot:
dot = Dot(graph_type='digraph')
dot.leftNodesLookup = {}
nodes = {}
for N, prop, q in sipGraph.query(
'SELECT ?N ?prop ?q { ?prop a magic:SipArc . ?N ?prop ?q . }',
initNs={u'magic': MAGIC}):
if MAGIC.BoundHeadPredicate in sipGraph.objects(subject=N,
predicate=RDF.type):
NCol = [N]
else:
NCol = Collection(sipGraph, N)
if q not in nodes:
newNode = Node(makeMD5Digest(q),
label=normalizeTerm(q, sipGraph),
shape='plaintext')
nodes[q] = newNode
dot.add_node(newNode)
bNode = BNode()
nodeLabel = ', '.join([normalizeTerm(term, sipGraph) for term in NCol])
edgeLabel = ', '.join([
var.n3() for var in Collection(
sipGraph, first(sipGraph.objects(prop, MAGIC.bindings)))
])
markedEdgeLabel = ''
if nodeLabel in dot.leftNodesLookup:
bNode, leftNode, markedEdgeLabel = dot.leftNodesLookup[nodeLabel]
# print "\t",nodeLabel,edgeLabel, markedEdgeLabel,not edgeLabel == markedEdgeLabel
else:
leftNode = Node(makeMD5Digest(bNode),
label=nodeLabel,
shape='plaintext')
dot.leftNodesLookup[nodeLabel] = (bNode, leftNode, edgeLabel)
nodes[bNode] = leftNode
dot.add_node(leftNode)
if not edgeLabel == markedEdgeLabel:
edge = Edge(leftNode, nodes[q], label=edgeLabel)
dot.add_edge(edge)
return dot
class ContentTypeGraph(BaseGraph):
""" Draw a graph for ContentType
"""
@property
def graph(self):
""" Construct graph and mark broken relations if any
"""
if self._graph is not None:
return self._graph
self._graph = PyGraph()
# This node
name = self.context.getId()
node = queryAdapter(self.context, INode)
self._graph.add_node(node())
xtool = queryAdapter(self.context, IToolAccessor)
for relation in xtool.relations(proxy=False):
field = relation.getField('to')
value_from = field.getAccessor(relation)()
field = relation.getField('from')
value_to = field.getAccessor(relation)()
if name == value_from:
nto = self.tool.get(value_to)
if (value_from != value_to) and nto:
node = queryAdapter(nto, INode)
self._graph.add_node(node())
edge = queryAdapter(relation, IEdge)()
if edge:
self._graph.add_edge(edge)
else:
self._bad_content.add(value_to)
self._bad_relations.add(relation.Title())
elif name == value_to:
nfrom = self.tool.get(value_from)
if (value_from != value_to) and nfrom:
node = queryAdapter(nfrom, INode)
self._graph.add_node(node())
edge = queryAdapter(relation, IEdge)()
if edge:
self._graph.add_edge(edge)
else:
self._bad_content.add(value_from)
self._bad_relations.add(relation.Title())
return self._graph
def draw(self, name, dname, draw_branches=True):
"""
Writes the current graph as a PNG file
:param str name: filename (without .png)
:param str dname: directory of the output png
:param draw_branches:
:return:
"""
from pydot import Dot, Edge
import os
g = Dot()
g.set_node_defaults(color='lightgray',
style='filled',
shape='box',
fontname='Courier',
fontsize='10')
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color='green'))
g.add_edge(Edge(str(node), str(node.false), color='red'))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
for except_node in self.catch_edges.get(node, []):
g.add_edge(Edge(str(node),
str(except_node),
color='black',
style='dashed'))
g.write(os.path.join(dname, '%s.png' % name), format='png')
def _draw_subgraph(diagram: pydot.Dot, label_last_seen: DefaultDict[str,
str],
subgraph_name: str,
subgraph_ops: List[Union[Op, Trace]]) -> 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))
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()
subgraph.add_node(pydot.Node(node_id, label=label, texlbl=texlbl))
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 plot_tree(sent_id):
global sentences
graph = Dot(graph_type='digraph')
basic_dependencies = sentences[sent_id].findall(
"./dependencies[@type='collapsed-dependencies']/dep")
for dep in basic_dependencies:
gov = "{}\n{}".format(dep[0].get("idx"), dep[0].text)
dep = "{}\n{}".format(dep[1].get("idx"), dep[1].text)
graph.add_node(Node(gov))
graph.add_node(Node(dep))
graph.add_edge(Edge(dep, gov))
graph.write_png(f"sentence_{sent_id}.png")
class Graph(object): def __init__(self, sentence): self.dot = Dot() self.parse_sentence(sentence) def add(self, word1, word2): self.dot.add_edge(Edge(word1, word2)) return word1 def instantiate(self, word): return self.add(uniqueid(), word) def parse_sentence(self, sentence): for word1, word2 in pairwise(map(self.instantiate,tokenize(sentence))): self.add(word1, word2)
def main(input):
state_obj = yaml.load(input)
graph = Dot("states", graph_type='digraph')
rules = {
'require': {
'color': 'blue'
},
'require_in': {
'color': 'blue',
'reverse': True
},
'watch': {
'color': 'red'
},
'watch_in': {
'color': 'red',
'reverse': True
},
}
for top_key, props in state_obj.iteritems():
# Add a node for each state type embedded in this state
# keys starting with underscores are not candidates
if top_key == '__extend__':
# TODO - merge these into the main states and remove them
sys.stderr.write("Removing __extend__ states:\n{0}\n".format(
str(props)))
continue
for top_key_type, states in props.iteritems():
if top_key_type[:2] == '__':
continue
node_name = make_node_name(top_key_type, top_key)
graph.add_node(Node(node_name))
for edge_type, ruleset in rules.iteritems():
for relname in find_edges(states, edge_type):
if 'reverse' in ruleset and ruleset['reverse']:
graph.add_edge(
Edge(node_name, relname, color=ruleset['color']))
else:
graph.add_edge(
Edge(relname, node_name, color=ruleset['color']))
graph.write('/dev/stdout')
def draw(self, path: str, format: str = "raw") -> None:
node_aggr = {}
for node in self._nodes:
level = node.get_level()
label = node.get_label()
identifier = node.get_id()
if node_aggr.get(level) is None:
node_aggr[level] = {}
if level != 0:
gv_cluster = GVCluster(identifier)
gv_cluster.set("label", label)
node_aggr[level][identifier] = gv_cluster
else:
gv_node = GVNode(identifier)
gv_node.set("label", label)
node_aggr[level][identifier] = gv_node
gv_dot = GVDot()
gv_dot.set("ranksep", "1.0 equally")
if self._lable is not None:
gv_dot.set("label", self._lable)
for node in self._nodes:
level = node.get_level()
parent = node.get_parent()
parent_level = node.get_parent_level()
identifier = node.get_id()
if level != 0:
if parent is not None:
node_aggr[parent_level][parent].add_subgraph(node_aggr[level][identifier])
else:
gv_dot.add_subgraph(node_aggr[level][identifier])
else:
if parent is not None:
node_aggr[parent_level][parent].add_node(node_aggr[level][identifier])
else:
gv_dot.add_node(node_aggr[level][identifier])
for edge in self._edges:
label = edge.get_label()
gv_edge = GVEdge(edge.get_src(), edge.get_dst())
if label is not None:
gv_edge.set("label", edge.get_label())
gv_dot.add_edge(gv_edge)
gv_dot.write(path, format=format)
def graph(nodes, name="HEX", dname="graphs", initial_player=Player.PLAYER_1):
g = Dot(graph_type="digraph", nodesep=0.5)
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
added = []
for node in nodes:
xlabel = str(node.owner) if node.owner is not None else ""
if xlabel == "both": xlabel = ""
g.add_node(pydot.Node(hash(node), label=node_str(node), shape="hexagon", width=0.1, height=0.1,
color=color_of_node(node), xlabel=xlabel))
for suc in node.neighbours:
if suc not in added:
g.add_edge(Edge(node.__hash__(), suc.__hash__(), color=color_of_node(suc, True), arrowhead="None"))
added.append(node)
g.write_png('%s/%s.png' % (dname, name), prog='neato')
def visualize_fpta(red):
red_sorted = sorted(list(red), key=lambda x: len(x.prefix))
graph = Dot('fpta', graph_type='digraph')
for i, r in enumerate(red_sorted):
r.state_id = f'q{i}'
graph.add_node(Node(r.state_id, label=r.state_id))
for r in red_sorted:
for i, c in r.children.items():
graph.add_edge(Edge(r.state_id, c.state_id, label=i))
graph.add_node(Node('__start0', shape='none', label=''))
graph.add_edge(Edge('__start0', red_sorted[0].state_id, label=''))
return graph
def process_plan(filename, plan):
graph = Dot()
teams = fetch_teams()
nodes = make_nodes(plan, teams)
for team_node in nodes:
graph.add_node(nodes[team_node])
for team in plan:
edges = graph_way(team, plan[team], nodes)
for edge in edges:
graph.add_edge(edge)
graph.set_prog("circo")
graph.write_png(filename)
def renderNetwork(network, nsMap={}):
"""
Takes an instance of a compiled ReteNetwork and a namespace mapping (for constructing QNames
for rule pattern terms) and returns a BGL Digraph instance representing the Rete network
#(from which GraphViz diagrams can be generated)
"""
# from FuXi.Rete import BuiltInAlphaNode
# from BetaNode import LEFT_MEMORY, RIGHT_MEMORY, LEFT_UNLINKING
dot = Dot(graph_type='digraph')
namespace_manager = NamespaceManager(Graph())
for prefix, uri in list(nsMap.items()):
namespace_manager.bind(prefix, uri, override=False)
visitedNodes = {}
edges = []
idx = 0
for node in list(network.nodes.values()):
if node not in visitedNodes:
idx += 1
visitedNodes[node] = generateBGLNode(dot, node, namespace_manager,
str(idx))
dot.add_node(visitedNodes[node])
nodeIdxs = {}
for node in list(network.nodes.values()):
for mem in node.descendentMemory:
if not mem:
continue
bNode = mem.successor
for bNode in node.descendentBetaNodes:
for idx, otherNode in enumerate([bNode.leftNode, bNode.rightNode]):
if node == otherNode and (node, otherNode) not in edges:
for i in [node, bNode]:
if i not in visitedNodes:
idx += 1
nodeIdxs[i] = idx
visitedNodes[i] = generateBGLNode(
dot, i, namespace_manager, str(idx))
dot.add_node(visitedNodes[i])
edge = Edge(visitedNodes[node],
visitedNodes[bNode],
label=idx == 0 and 'left' or 'right')
dot.add_edge(edge)
edges.append((node, bNode))
return dot
def renderNetwork(network, nsMap={}):
"""
Takes an instance of a compiled ReteNetwork and a namespace mapping (for constructing QNames
for rule pattern terms) and returns a BGL Digraph instance representing the Rete network
#(from which GraphViz diagrams can be generated)
"""
# from FuXi.Rete import BuiltInAlphaNode
# from BetaNode import LEFT_MEMORY, RIGHT_MEMORY, LEFT_UNLINKING
dot = Dot(graph_type='digraph')
namespace_manager = NamespaceManager(Graph())
for prefix, uri in list(nsMap.items()):
namespace_manager.bind(prefix, uri, override=False)
visitedNodes = {}
edges = []
idx = 0
for node in list(network.nodes.values()):
if node not in visitedNodes:
idx += 1
visitedNodes[node] = generateBGLNode(
dot, node, namespace_manager, str(idx))
dot.add_node(visitedNodes[node])
nodeIdxs = {}
for node in list(network.nodes.values()):
for mem in node.descendentMemory:
if not mem:
continue
bNode = mem.successor
for bNode in node.descendentBetaNodes:
for idx, otherNode in enumerate([bNode.leftNode, bNode.rightNode]):
if node == otherNode and (node, otherNode) not in edges:
for i in [node, bNode]:
if i not in visitedNodes:
idx += 1
nodeIdxs[i] = idx
visitedNodes[i] = generateBGLNode(
dot, i, namespace_manager, str(idx))
dot.add_node(visitedNodes[i])
edge = Edge(visitedNodes[node],
visitedNodes[bNode],
label=idx == 0 and 'left' or 'right')
dot.add_edge(edge)
edges.append((node, bNode))
return dot
def indiv_with_sub(df, outfolder):
thislist, deptlist = get_reports(df)
for x in list(set([i[1] for i in thislist])):
graph = Dot(graph_type='graph',
ratio='auto',
size=150,
dpi=150,
splines='ortho')
#people who report to x
reports = [y for y in thislist if y[1] == x]
#and the people they report to
reports2 = [y for y in thislist if y[1] in [z[0] for z in reports]]
reporting = reports + reports2
reporting = list(set(reporting))
for report_to, report in reporting:
graph.add_edge(Edge(report, report_to))
print(f"Now writing file for {x}")
graph.write_png(f"{outfolder}\\{x}.png")
def _add_edge(progenitor: pydot.Dot, op: Union[Trace, Op], label_last_seen: Dict[str, str]):
"""Draw edges into a given Node.
Args:
progenitor: The very top level diagram onto which Edges should be written.
op: The op (or trace) to be visualized.
label_last_seen: A mapping of {data_dict_key: node_id} indicating the last node which generated the key.
"""
node_id = str(id(op))
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():
progenitor.add_edge(pydot.Edge(src=src, dst=node_id, label=f" {', '.join(labels)} "))
for out in op.outputs:
label_last_seen[out] = node_id
def process_plan(filename, plan, names=True, with_dist=False, with_label=False):
graph = Dot(overlap="false", splines="true", esep=.2)
teams = fetch_teams()
distances = fetch_distances()
nodes = make_nodes(plan, teams, names)
for team_node in nodes:
graph.add_node(nodes[team_node])
for team in plan:
edges = graph_way(team, plan[team], nodes, distances, with_dist, with_label)
for edge in edges:
graph.add_edge(edge)
if with_dist:
graph.write_png(filename, prog="neato")
else:
graph.write_png(filename, prog="dot")
def markBrokenRelations(self):
""" Construct graph and return message with info about broken
relations for ToolGraph if any errors are found
"""
bad_relations = []
bad_content = []
bad_rel = ""
graph = PyGraph()
tool = queryAdapter(self.context, IToolAccessor)
types = tool.types(proxy=False)
for ctype in types:
node = queryAdapter(ctype, INode)
graph.add_node(node())
relations = tool.relations(proxy=False)
for relation in relations:
edge = queryAdapter(relation, IEdge)
res = edge()
if res:
graph.add_edge(res)
continue
else:
# if no result then check which relation id is missing
from_rel = relation['from']
to_rel = relation['to']
pr_from = self.pt_relations.get(from_rel)
pr_to = self.pt_relations.get(to_rel)
if not pr_from:
bad_rel = from_rel
if not pr_to:
bad_rel = to_rel
if bad_rel and bad_rel not in bad_content:
bad_content.append(bad_rel)
bad_relations.append(relation.Title())
self.graph_res = graph
if bad_relations:
return self.brokenRelationMessage(bad_content, bad_relations)
return ""
class ToolGraph(BaseGraph):
""" Draw a graph for portal_relations
"""
@property
def graph(self):
""" Construct graph and mark broken relations if any
"""
if self._graph is not None:
return self._graph
self._graph = PyGraph()
xtool = queryAdapter(self.context, IToolAccessor)
typesIds = set()
for ctype in xtool.types(proxy=False):
typesIds.add(ctype.getId())
node = queryAdapter(ctype, INode)
self._graph.add_node(node())
for relation in xtool.relations(proxy=False):
field = relation.getField('to')
value_from = field.getAccessor(relation)()
field = relation.getField('from')
value_to = field.getAccessor(relation)()
edge = queryAdapter(relation, IEdge)()
if edge:
self._graph.add_edge(edge)
else:
self._bad_relations.add(relation.Title())
if value_from not in typesIds:
self._bad_content.add(value_from)
if value_to not in typesIds:
self._bad_content.add(value_to)
return self._graph
def markBrokenRelations(self):
""" Construct graph and return message with info about broken
relations for RelationGraph if any errors are found
"""
bad_relations = []
bad_content = []
bad_rel = ""
graph = PyGraph()
value_from = self.context.getField('from').getAccessor(self.context)()
nfrom = self.pt_relations.get(value_from)
if nfrom:
node = queryAdapter(nfrom, INode)
graph.add_node(node())
value_to = self.context.getField('to').getAccessor(self.context)()
nto = self.pt_relations.get(value_to)
if not (value_from == value_to) and nto:
node = queryAdapter(nto, INode)
graph.add_node(node())
edge = queryAdapter(self.context, IEdge)
res = edge()
if res:
graph.add_edge(res)
self.graph_res = graph
return ""
if not nfrom:
bad_rel = value_from
if not nto:
bad_rel = value_to
relation = self.pt_relations[self.context.getId()]
if bad_rel and bad_rel not in bad_content:
bad_content.append(bad_rel)
bad_relations.append(relation.Title())
self.graph_res = graph
return self.brokenRelationMessage(bad_content, bad_relations)
def main(input):
state_obj = yaml.load(input)
graph = Dot("states", graph_type='digraph')
rules = {
'require': {'color': 'blue'},
'require_in': {'color': 'blue', 'reverse': True},
'watch': {'color': 'red'},
'watch_in': {'color': 'red', 'reverse': True},
}
for top_key, props in state_obj.iteritems():
# Add a node for each state type embedded in this state
# keys starting with underscores are not candidates
if top_key == '__extend__':
# TODO - merge these into the main states and remove them
sys.stderr.write(
"Removing __extend__ states:\n{0}\n".format(str(props)))
continue
for top_key_type, states in props.iteritems():
if top_key_type[:2] == '__':
continue
node_name = make_node_name(top_key_type, top_key)
graph.add_node(Node(node_name))
for edge_type, ruleset in rules.iteritems():
for relname in find_edges(states, edge_type):
if 'reverse' in ruleset and ruleset['reverse']:
graph.add_edge(Edge(
node_name, relname, color=ruleset['color']))
else:
graph.add_edge(Edge(
relname, node_name, color=ruleset['color']))
graph.write('/dev/stdout')
def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge
g = Dot()
g.set_node_defaults(color="lightgray", style="filled", shape="box", fontname="Courier", fontsize="10")
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color="green"))
g.add_edge(Edge(str(node), str(node.false), color="red"))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color="blue"))
for except_node in self.catch_edges.get(node, []):
g.add_edge(Edge(str(node), str(except_node), color="black", style="dashed"))
g.write_png("%s/%s.png" % (dname, name))
def save(self, cf, filename, format='dot'):
"""Save basic block graph into a file.
"""
try:
dot_graph = Dot(**self.graph_format)
# add nodes
nodes = {}
for cfg_addr in cf._graph.node.keys():
nodes[cfg_addr] = self._create_node(cfg_addr, cf)
dot_graph.add_node(nodes[cfg_addr])
# add edges
for cfg_src_addr in cf._graph.node.keys():
for cfg_dst_addr in cf._edges.get(cfg_src_addr, []):
edge = self._create_edge(nodes, cfg_src_addr, cfg_dst_addr)
dot_graph.add_edge(edge)
dot_graph.write("{}.{}".format(filename, format), format=format)
except Exception:
logger.error("Failed to save call graph: %s (%s)", filename, format, exc_info=True)
class RelationGraph(BaseGraph):
""" Draw a graph for Relation
"""
@property
def graph(self):
""" Construct graph and mark broken relations if any
"""
if self._graph is not None:
return self._graph
# Valid graph edge
self._graph = PyGraph()
value_from = self.context.getField('from').getAccessor(self.context)()
nfrom = self.tool.get(value_from)
if nfrom:
node = queryAdapter(nfrom, INode)
self._graph.add_node(node())
else:
self._bad_content.add(value_from)
self._bad_relations.add(self.context.Title())
value_to = self.context.getField('to').getAccessor(self.context)()
nto = self.tool.get(value_to)
if nto:
if value_from != value_to:
node = queryAdapter(nto, INode)
self._graph.add_node(node())
else:
self._bad_content.add(value_to)
self._bad_relations.add(self.context.Title())
edge = queryAdapter(self.context, IEdge)()
if edge:
self._graph.add_edge(edge)
return self._graph
def draw(self, name, dname, draw_branches=True):
from pydot import Dot, Edge
g = Dot()
g.set_node_defaults(color='lightgray', style='filled', shape='box',
fontname='Courier', fontsize='10')
for node in sorted(self.nodes, key=lambda x: x.num):
if draw_branches and node.type.is_cond:
g.add_edge(Edge(str(node), str(node.true), color='green'))
g.add_edge(Edge(str(node), str(node.false), color='red'))
else:
for suc in self.sucs(node):
g.add_edge(Edge(str(node), str(suc), color='blue'))
for except_node in self.catch_edges.get(node, []):
g.add_edge(Edge(str(node), str(except_node),
color='black', style='dashed'))
g.write_png('%s/%s.png' % (dname, name))
class Sitemap(object):
URI_FAILURE = "failed to read URI '%s'"
current_contents = None
base_uri = None
base_url = None
current_uri = None
current_url = None
site_graph = None
def __init__(self):
self.site_dict = { 'pages': [],
'links': {},
'assets': { 'imgs': [],
'scripts': [],
'stylesheets': [] }
}
def from_uri(self, uri, render_opts={}):
""" sets the instance URI and renders a sitemap image
"""
self.base_uri = uri
self.base_url = urlparse(uri)
if self.traverse_site( uri ):
self.render_sitemap( render_opts )
else:
return self.URI_FAILURE % uri
def build_site_graph(self):
self.site_graph = Dot(graph_type='digraph')
self.site_graph.set_label( 'Sitemap for "%s"' % self.base_uri )
self.site_graph.set_simplify( True )
# add nodes
for page in self.site_dict['pages']:
self.site_graph.add_node( page.to_node() )
# add edges
for page in self.site_dict['pages']:
from_node = page.uri
for link in page.attributes['links']:
to_node = link
self.site_graph.add_edge( Edge(from_node, to_node) )
def render_sitemap(self, options={}):
if self.site_graph is None:
self.build_site_graph()
file_fmt = 'png'
if 'format' in options.keys() and options['format'] is not None:
file_fmt = options['format']
filename = 'sitemap.%s' % file_fmt
if 'filename' in options.keys() and options['filename'] is not None:
filename = options['filename']
self.site_graph.write(filename, 'dot', file_fmt)
# with open(filename, 'w') as sitemap_img:
# sitemap_img.write("TODO")
def traverse_site(self, uri_str):
if self.validate_uri( uri_str ):
# populate site_dict
print "%d traversing %s" % (int(time.time()), uri_str)
page_dict = { 'assets': { 'imgs': [],
'scripts': [],
'stylesheets': []
},
'links': []
}
self.current_contents = urllib.urlopen( uri_str ).read()
self.current_uri = uri_str
self.current_url = urlparse( uri_str )
self.base_url = self.base_url or self.current_url
html_doc = BeautifulSoup( self.current_contents )
# get all scripts, stylesheets and images
for script in html_doc.find_all('script'):
src = script.get('src')
if src is not None:
page_dict['assets']['scripts'].append( src )
sset = set(self.site_dict['assets']['scripts'])
pset = set(page_dict['assets']['scripts'])
# list of unique js sources for the site
self.site_dict['assets']['scripts'] = list( sset | pset )
for css in html_doc.select('link[rel="stylesheet"]'):
href = css.get('href')
if href is not None:
page_dict['assets']['stylesheets'].append( href )
sset = set(self.site_dict['assets']['stylesheets'])
pset = set(page_dict['assets']['stylesheets'])
# list of unique stylesheets for the site
self.site_dict['assets']['stylesheets'] = list( sset | pset )
for img in html_doc.select('img'):
src = img.get('src')
if src is not None and src not in page_dict['assets']['imgs']:
page_dict['assets']['imgs'].append( src )
sset = set(self.site_dict['assets']['imgs'])
pset = set(page_dict['assets']['imgs'])
# list of unique images for the site
self.site_dict['assets']['imgs'] = list( sset | pset )
# get all internal links on the page
for link in html_doc.select('a'):
href = link.get('href').split('#')[0]
href_uri = urljoin( self.base_url.geturl(), href )
if self.valid_internal_link(href):
if href_uri not in page_dict['links']:
page_dict['links'].append( href_uri )
if href_uri not in self.site_dict['links'].keys():
self.site_dict['links'][ href_uri ] = Link(href_uri, 'new')
# add the current page and set it as processed
self.site_dict['pages'].append( Page(self.current_uri, page_dict) )
self.site_dict['links'][ self.current_uri ] = Link(self.current_uri, 'processed')
# traverse any linked pages
for uri, link_obj in self.site_dict['links'].iteritems():
if link_obj.status is 'new':
self.traverse_site( uri )
return True
else:
return False
def valid_internal_link( self, href ):
""" returns True if the argument domain is the same as the current url """
href_url = urlparse( href )
if href is not None and \
href_url.netloc in ['', self.base_url.netloc] and \
re.match(r"""(?!(?:mailto|javascript))""", href):
return True
else:
return False
def validate_uri(self, uri):
""" validates a URI is well formed and readable
"""
if uri is not None:
u = urlparse( uri )
conn = httplib.HTTPConnection( u.netloc )
if u.scheme == 'https':
conn = httplib.HTTPSConnection( u.netloc )
path = u.path or "/"
try:
conn.request("HEAD", path)
response = conn.getresponse()
if response.status == 200:
return True
else:
return False
except Exception, e:
print self.URI_FAILURE % uri
return False
finally:
