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 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 __init__(self, nome, custo, vertice1, vertice2): self.__nome = nome self.__custo = custo self.__vertice1 = vertice1 self.__vertice2 = vertice2 self.__aresta = Edge(str(vertice1.getNome()), str(vertice2.getNome())) self.__aresta.set_label(custo) self.__aresta.set_labelfontcolor("#009933") self.__aresta.set_fontsize(10.0) self.__aresta.set_color("#38516b")
def add_edge(self,*args,**kwargs): if len(args)==1 and isinstance(args[0],Edge): edge = args[0] else: edge = Edge(*args,**kwargs) #end if src = edge.get_source() dst = edge.get_destination() self.edges[src,dst] = edge self.graph.add_edge(edge)
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 mk_merge_edge(graph, src_node, tgt_node, kind, label, important): """Add a merge edge to the graph""" if important: color = "red" else: color = "grey" e = Edge( src_node, tgt_node, constraint="false", label='"' + label + '"', color=color, fontcolor=color, style="bold" ) if kind.startswith("cherry"): e.set_style("dashed") graph.add_edge(e)
def accept_BinaryExpression(self, node): n1 = create_node(str(node.type)) n2 = self.accept(node.left_expr) n3 = self.accept(node.right_expr) e1 = Edge(n1, n2) e2 = Edge(n1, n3) self.graph.add_node(n1) self.graph.add_edge(e1) self.graph.add_edge(e2) return n1
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')) g.write_png('%s/%s.png' % (dname, name))
def mk_merge_edge(graph, src_node, tgt_node, kind, label, important): """Add a merge edge to the graph""" if important: color = 'red' else: color = 'grey' e = Edge(src_node, tgt_node, constraint='false', label='"' + label + '"', color=color, fontcolor=color, style='bold') if kind.startswith('cherry'): e.set_style('dashed') graph.add_edge(e)
def _print_tree(self, graph): root = self.get_node_str() if self.is_leaf: return graph left_tree_str = self.left_tree.get_node_str() right_tree_str = self.right_tree.get_node_str() # print('left', left_tree_str) # print('right', right_tree_str) graph.add_edge(Edge(src=root, dst=left_tree_str)) graph = self.left_tree._print_tree(graph) graph.add_edge(Edge(src=root, dst=right_tree_str)) graph = self.right_tree._print_tree(graph) return graph
def accept_BitExtraction(self, node): n1 = create_node("BitExtraction") n2 = create_node(str(node.identifier)) self.graph.add_node(n1) self.graph.add_node(n2) self.graph.add_edge(Edge(n1, n2)) for r in node.range: n = self.accept(r) self.graph.add_edge(Edge(n1, n)) return 1
class Aresta(): def __init__(self, nome, custo, vertice1, vertice2): self.__nome = nome self.__custo = custo self.__vertice1 = vertice1 self.__vertice2 = vertice2 self.__aresta = Edge(str(vertice1.getNome()), str(vertice2.getNome())) self.__aresta.set_label(custo) self.__aresta.set_labelfontcolor("#009933") self.__aresta.set_fontsize(10.0) self.__aresta.set_color("#38516b") def setNome(self, nome): self.__nome = nome def setCusto(self, custo): self.__custo = custo def getNome(self): return self.__nome def getCusto(self): return self.__custo def getVertice1(self): return self.__vertice1 def getVertice2(self): return self.__vertice2 def getVertices(self): return [self.__vertice1, self.__vertice2] def getAresta(self): return self.__aresta
def accept_CaseElement(self, node): n1 = create_node("CaseElement") n2 = self.accept(node.value) n3 = create_node("statements") self.graph.add_node(n1) self.graph.add_node(n3) self.graph.add_edge(Edge(n1, n2)) self.graph.add_edge(Edge(n1, n3)) for st in node.statements: st_node = self.accept(st) self.graph.add_edge(Edge(n3, st_node)) return n1
def accept_Case(self, node): n1 = create_node("Case") n2 = self.accept(node.expr) n3 = create_node("cases") self.graph.add_node(n1) self.graph.add_node(n3) self.graph.add_edge(Edge(n1, n2)) self.graph.add_edge(Edge(n1, n3)) for st in node.cases: st_node = self.accept(st) self.graph.add_edge(Edge(n3, st_node)) return n1
def __init__(self, src, dst, attr): obj_dict = dict() obj_dict[ 'attributes' ] = attr obj_dict[ 'type' ] = 'edge' obj_dict[ 'parent_graph' ] = None obj_dict[ 'parent_edge_list' ] = None obj_dict[ 'sequence' ] = None if isinstance(src, Node): src = src.get_name() if isinstance(dst, Node): dst = dst.get_name() points = ( quote_if_necessary( src) , quote_if_necessary( dst) ) obj_dict['points'] = points Edge.__init__(self, src, dst, obj_dict)
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 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 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 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 add_edge(graph, tail_node, head_node, label="[0%]", style="solid, bold", color="black", constraint="true"): """ Add an edge to a graph or subgraph :param graph: graph or subgraph to which the edge is added :param tail_node: origin of the edge :param head_node: destination of the edge :param label: the label :param style: the style :param color: the color :param constraint: the constraint """ edge = Edge(tail_node, head_node, label=label, style=style, color=color, constraint="true") graph.add_edge(edge) return
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 add_annotation(graph, node, label, color='lightblue'): """Add a graph node that serves as an annotation to a normal node. More than one annotation can be added to the same normal node.""" subg_name = node + '_annotations' def get_subgraph(graph, name): """Equivalent to pydot.Graph.get_subgraph() when there is no more than one subgraph of the given name, but working aroung a bug in pydot.Graph.get_subgraph().""" for subg in graph.get_subgraph_list(): if subg.get_name() == name: return subg return None g = get_subgraph(graph, subg_name) if not g: g = pydot.Subgraph(subg_name, rank='same') graph.add_subgraph(g) ann_node = node + '_' while g.get_node(ann_node): ann_node = ann_node + '_' g.add_node( Node(ann_node, shape='box', style='filled', color=color, label='"' + label + '"')) g.add_edge( Edge(ann_node, node, style='solid', color=color, dir='none', constraint='false'))
def _create_edge(self, nodes, cfg_src_addr, cfg_dst_addr): if cfg_dst_addr == "unknown": branch_type = "indirect" else: branch_type = "direct" return Edge(nodes[cfg_src_addr], nodes[cfg_dst_addr], color=self.edge_color[branch_type], **self.edge_format)
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 accept_RepeatUntil(self, node): n1 = create_node("RepeatUntil") n2 = create_node(self.accept(node.condition)) n3 = create_node("statements") self.graph.add_edge(Edge(n1, n2)) self.graph.add_edge(Edge(n1, n3)) self.graph.add_node(n1) self.graph.add_node(n2) self.graph.add_node(n3) for st in node.statements: st_node = self.accept(st) self.graph.add_edge(Edge(n3, st_node)) return n1
def accept_ProcedureCall(self, node): n1 = create_node("call") n2 = create_node(str(node.name)) n3 = create_node("arguments") self.graph.add_node(n1) self.graph.add_node(n2) self.graph.add_node(n3) self.graph.add_edge(Edge(n1, n2)) self.graph.add_edge(Edge(n1, n3)) for arg in node.arguments: arg_node = self.accept(arg) self.graph.add_edge(Edge(n3, arg_node)) return n1
def start_graph(g, node, parent_node_name=None): g.add_node( Node(name=node.getNodeNum(), shape='plaintext', label=node.getLabel())) if parent_node_name: g.add_edge(Edge(parent_node_name, node.getNodeNum())) if len(node.getKids()) > 0: for kid in node.getKids(): start_graph(g, kid, node.getNodeNum()) else: g.add_node( Node(name=f'{node.getNodeNum()}_content', shape='plaintext', label=node.getContent())) g.add_edge( Edge(node.getNodeNum(), f'{node.getNodeNum()}_content'))
def add_edge_to_parent(node, is_successor=False, parent=None): if parent is None: parent = node.parent g_node = add_node(node, in_successors=is_successor) g_parent_node = add_node(parent) edge = Edge(g_parent_node, g_node, label=node.action_representation(), fontsize=self.font_size) if is_successor: edge.set_color(self.successor_color) edge.set_labelfontcolor(self.successor_color) graph_edges[id(node), id(parent)] = edge
def accept_UnaryExpression(self, node): n1 = create_node(str(node.type)) n2 = self.accept(node.expr) e = Edge(n1, n2) self.graph.add_node(n1) self.graph.add_edge(e) return n1
def draw_missing_child(self, context: DrawContext, parent: Node) -> None: """Adds an empty node and edge for nodes with a single child. This avoids quirky behavior from drawing additional edges in graphs where the extra edge would run past nodes with only a single child. """ target = f":d{id(parent)}" context.graph.add_node(DotNode(target, **self.hidden_node)) context.graph.add_edge(Edge(str(id(parent)), target, style="invis"))
def get_nodes_and_edges(name='my_graph'): graph = Graph(cleanup(name)) edges = [] for orm_node in Node.objects.select_related(): graph.add_node(get_node(orm_node.name)) for parent in orm_node.parent.iterator(): edges.append((cleanup(parent.parent.name),cleanup(parent.child.name))) for child in orm_node.child.iterator(): edges.append((cleanup(child.parent.name),cleanup(child.child.name))) edges = list(set(edges)) # remove duplicates for edge in edges: e = Edge(edge[0],edge[1]) e.set_target('_parent') e.set_arrowhead('vee') graph.add_edge(e) return graph
def mk_edge(graph, name1, name2, **attrs): """Add an ordinary edge to the graph""" graph.add_edge( Edge(name1, name2, dir='none', style='dotted', color='grey', **attrs))
def aresta(self, v1, v2): if v2 in self.__adjmx__[v1]: return False self.__adjmx__[v1].append(v2) self.__adjmx__[v2].append(v1) self.__arest__ = self.__arest__ + 1 if self.__graph__ is not None: self.__graph__.add_edge(Edge(str(v1), str(v2))) return True
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 generate_links(graph, state_obj, nodes, nodemap): rules = { 'require': {'color': '#0000ff'}, 'require_in': {'color': '#9090ff', 'reverse': True, 'style': 'dashed', }, 'watch': {'color': '#ff0000'}, 'watch_in': {'color': '#ff9090', 'reverse': True, 'style': 'dashed', }, } seen = set() for state in state_obj: node_name = '{0}.{1}'.format(state.get('state'), state.get('__id__')) if node_name in seen: continue seen.add(node_name) for edge_type, ruleset in rules.items(): for target in targets_name(state.get(edge_type), nodes, nodemap): src, dst = node_name, target if ruleset.get('reverse'): src, dst = dst, src edge = Edge(dst, src, color=ruleset['color']) if 'style' in ruleset: edge.set_style(ruleset.get('style')) graph.add_edge(edge)
def get_node_and_edges(name): graph = Graph(cleanup(name)) orm_node = Node.objects.select_related().get(name=name) other_nodes = [x for x in orm_node.parent.iterator()] other_nodes += [x for x in orm_node.child.iterator()] edges = [] node_check = [] # used to make sure we don't add the same node twice for other_node in other_nodes: if other_node.parent.name not in node_check: graph.add_node(get_node(other_node.parent.name)) node_check.append(other_node.parent.name) if other_node.child.name not in node_check: graph.add_node(get_node(other_node.child.name)) node_check.append(other_node.child.name) # edges are tuples edges.append((cleanup(other_node.parent.name),cleanup(other_node.child.name))) edges = list(set(edges)) # remove duplicates for edge in edges: e = Edge(edge[0],edge[1]) e.set_arrowhead('vee') graph.add_edge(e) return graph
from pyd.atm_state import * from pydot import Dot, Node, Edge file = "/tmp/atm_state_machine.png" dot = Dot(graph_type="digraph", comment="Atm State Machine") nodes = {} graph = {} for name, state in State.get_subclasses_dict().iteritems(): nodes.setdefault(name, Node(name)) for name, state in State.get_subclasses_dict().iteritems(): for event, state in state.get_valid_events(): edge = Edge(nodes.get(name), nodes.get(state)) edge.set_label(event) graph.setdefault(name, []).append(edge) for name, edges in graph.iteritems(): for edge in edges: dot.add_node(nodes.get(name)) dot.add_edge(edge) dot.write_png(file)