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 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
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 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: