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 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 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 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 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 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
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 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 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 draw(self, prob, targetFile): # Do the graphing stuff here... # Root graph g = Dot(graph_type="digraph", nodesep=2, overlap=False) #g.set_edge_defaults(weight="0", minlen="10") # Organise by adding constraints (adds edges too) for constr in prob.constrs: # Node for constraint constrNode = Node(constr.name, shape="ellipse", style="filled", fillcolor = "#aaaaff") constrNode.set_label(constr.name + ": " + constr.getTextFormula()) g.add_node(constrNode) # Associated expressions for expr in constr.exprs: self.addNodesForChildren(g, expr, constr) # Finally, render #g.write_png("problem_structure.png", prog="dot") g.write_png(targetFile, prog="neato")
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 render_state_diagram(C_M, S_M, filename, depth=None): tot_M = C_M + S_M if depth: reachable_states = find_reachable_states(tot_M, len(tot_M) - 1, depth) reachable_states.add(len(tot_M) - 1) else: reachable_states = range(len(tot_M)) graph = Dot(graph_type="digraph", rankdir="LR") nodes = [Node(str(i), shape="circle") for i in range(len(tot_M) + 1)] nodes[-2].set_shape("point") nodes[-1].set_shape("doublecircle") for i in reachable_states: graph.add_node(nodes[i]) graph.add_node(nodes[-1]) def _render_edges(M, color, end_state): for i in reachable_states: row_sum = sum(tot_M[i]) col_sum = sum(tot_M[:, i]) if not end_state: for j in reachable_states: elem = M[i, j] if elem > 0: if col_sum > 0: prob = elem / col_sum else: prob = elem / row_sum edge = Edge(nodes[i], nodes[j], label="%.2f" % prob, color=color) graph.add_edge(edge) else: if row_sum < col_sum: prob = (col_sum - row_sum) / col_sum edge = Edge(nodes[i], nodes[-1], label="%.2f" % prob, color=color) graph.add_edge(edge) _render_edges(C_M, "blue", False) _render_edges(S_M, "red", False) _render_edges(None, "black", True) graph.write_png(filename)
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 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 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 if state in self.final_states: initial_state_node = Node(state, style='filled', peripheries=2, fillcolor='#66cc33') else: initial_state_node = Node(state, style='filled', fillcolor='#66cc33') nodes[state] = initial_state_node graph.add_node(initial_state_node) else: if state in self.final_states: state_node = Node(state, peripheries=2) 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 save(self, cfg, filename, print_ir=False, format='dot'): """Save basic block graph into a file. """ 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) 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 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 ""
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
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 graph_representation(self): """ Construct a dot graph representation of these results. :return: The dot graph """ from pydot import Dot, Edge, Node g = Dot() for resource in self.resources: color = 'black' if resource in self.targets and self.consumed(resource) == 0: color = 'darkgreen' elif self.consumed(resource) == 0: color = 'brown' g.add_node(Node('i_' + resource, label='{:.3} {}'.format(float(self.produced(resource) + self.supplied(resource)), resource), color=color, style='dashed')) if resource in self.targets and self.consumed(resource) > 0: # add a second node if requested and consumed so we can see a terminal node g.add_node(Node('ir_' + resource, label='{:.3} {}'.format(float(self.requested(resource)), resource), color='darkgreen', style='dashed')) weight = self.requested(resource) g.add_edge(Edge('i_' + resource, 'ir_' + resource, label='{:.3}'.format(weight), weight=weight)) for recipe, batches in self.recipes.items(): if self.book.crafters_defined(): crafter = self.book.get_crafter_for(recipe) or Crafter('', 1) label = '{:.3} {}\n{}'.format(batches[1], crafter.name, recipe) else: label = '{:.3} {}'.format(batches[1], recipe) g.add_node(Node('r_' + recipe, label=label, shape='box')) r: Recipe = self.book[recipe] for output in r.outputs(): weight = r.produced(output, batches[1]) g.add_edge(Edge('r_' + recipe, 'i_' + output, label='{:.3}'.format(weight), weight=weight)) for input in r.inputs(): weight = r.consumed(input, batches[1]) g.add_edge(Edge('i_' + input, 'r_' + recipe, label='{:.3}'.format(weight), weight=weight)) return g
def visualize_pta(root_node, path='pta.pdf'): from pydot import Dot, Node, Edge graph = Dot('fpta', graph_type='digraph') graph.add_node(Node(str(root_node.prefix), label=f'{root_node.output}')) queue = [root_node] visited = set() visited.add(root_node.prefix) while queue: curr = queue.pop(0) for i, c in curr.children.items(): if c.prefix not in visited: graph.add_node(Node(str(c.prefix), label=f'{c.output}')) graph.add_edge(Edge(str(curr.prefix), str(c.prefix), label=f'{i}')) if c.prefix not in visited: queue.append(c) visited.add(c.prefix) graph.add_node(Node('__start0', shape='none', label='')) graph.add_edge(Edge('__start0', str(root_node.prefix), label='')) graph.write(path=path, format='pdf')
def save_automaton_to_file(automaton, path="LearnedModel", file_type='dot', display_same_state_trans=True, visualize=False): """ The Standard of the automata strictly follows the syntax found at: https://automata.cs.ru.nl/Syntax/Overview. For non-deterministic and stochastic systems syntax can be found on AALpy's Wiki. Args: automaton: automaton to be saved to file path: file in which automaton will be saved (Default value = "LearnedModel") file_type: Can be ['dot', 'png', 'svg', 'pdf'] (Default value = 'dot') display_same_state_trans: True, should not be set to false except from the visualization method (Default value = True) visualize: visualize the automaton Returns: """ assert file_type in file_types if file_type == 'dot' and not display_same_state_trans: print("When saving to file all transitions will be saved") display_same_state_trans = True is_dfa = isinstance(automaton, Dfa) is_moore = isinstance(automaton, MooreMachine) is_mdp = isinstance(automaton, Mdp) is_onsfm = isinstance(automaton, Onfsm) is_smm = isinstance(automaton, StochasticMealyMachine) is_mc = isinstance(automaton, MarkovChain) graph = Dot(path, graph_type='digraph') for state in automaton.states: if is_dfa and state.is_accepting: graph.add_node( Node(state.state_id, label=state.state_id, shape='doublecircle')) elif is_moore: graph.add_node( Node(state.state_id, label=f'{state.state_id}|{state.output}', shape='record', style='rounded')) elif is_mdp or is_mc: graph.add_node(Node(state.state_id, label=f'{state.output}')) else: graph.add_node(Node(state.state_id, label=state.state_id)) for state in automaton.states: if is_mc: for new_state, prob in state.transitions: graph.add_edge( Edge(state.state_id, new_state.state_id, label=f'{round(prob, 2)}')) continue for i in state.transitions.keys(): if isinstance(state, MealyState): new_state = state.transitions[i] if not display_same_state_trans and new_state.state_id == state.state_id: continue graph.add_edge( Edge(state.state_id, new_state.state_id, label=f'{i}/{state.output_fun[i]}')) elif is_mdp: # here we do not have single state, but a list of (State, probability) tuples new_state = state.transitions[i] for s in new_state: if not display_same_state_trans and s[ 0].state_id == state.state_id: continue graph.add_edge( Edge(state.state_id, s[0].state_id, label=f'{i} : {round(s[1], 2)}')) elif is_onsfm: new_state = state.transitions[i] for s in new_state: if not display_same_state_trans and state.state_id == s[ 1].state_id: continue graph.add_edge( Edge(state.state_id, s[1].state_id, label=f'{i}/{s[0]}')) elif is_smm: new_state = state.transitions[i] for s in new_state: if not display_same_state_trans and s[ 0].state_id == state.state_id: continue graph.add_edge( Edge(state.state_id, s[0].state_id, label=f'{i}/{s[1]}:{round(s[2], 2)}')) else: new_state = state.transitions[i] if not display_same_state_trans and new_state.state_id == state.state_id: continue graph.add_edge( Edge(state.state_id, new_state.state_id, label=f'{i}')) graph.add_node(Node('__start0', shape='none', label='')) graph.add_edge(Edge('__start0', automaton.initial_state.state_id, label='')) if file_type == 'string': return graph.to_string() else: try: graph.write(path=f'{path}.{file_type}', format=file_type if file_type != 'dot' else 'raw') print(f'Model saved to {path}.{file_type}.') if visualize and file_type in {'pdf', 'png', 'svg'}: try: import webbrowser abs_path = os.path.abspath(f'{path}.{file_type}') path = f'file:///{abs_path}' webbrowser.open(path) except OSError: traceback.print_exc() print(f'Could not open the file {path}.{file_type}.', file=sys.stderr) except OSError: traceback.print_exc() print(f'Could not write to the file {path}.{file_type}.', file=sys.stderr)
class GrapVisitor(Visitor): def __init__(self): self.graph = Dot(graph_type='digraph') def save(self, filename="graph.png"): self.graph.write_png(filename) def accept_BooleanValue(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_Identifier(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_NumberValue(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_List(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_Enumeration(self, node): n = create_node(str(node)) self.graph.add_node(n) return n 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 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 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 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_While(self, node): n1 = create_node("While") n2 = create_node(self.accept(node.condition)) n3 = create_node("statements") 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 st in node.statements: st_node = self.accept(st) self.graph.add_edge(Edge(n3, st_node)) return n1 def accept_For(self, node): n1 = create_node("For") n2 = create_node("from") n3 = create_node("to") n4 = create_node("statements") n5 = self.accept(node.from_) n6 = self.accept(node.to) self.graph.add_node(n1) self.graph.add_node(n2) self.graph.add_node(n3) self.graph.add_node(n4) self.graph.add_edge(Edge(n1, n2)) self.graph.add_edge(Edge(n1, n3)) self.graph.add_edge(Edge(n1, n4)) self.graph.add_edge(Edge(n2, n5)) self.graph.add_edge(Edge(n3, n6)) for st in node.statements: st_node = self.accept(st) self.graph.add_edge(Edge(n4, st_node)) return n1 def accept_If(self, node): n1 = create_node("If") n2 = create_node("condition") n3 = create_node("if_statements") n4 = create_node("else_statements") n5 = self.accept(node.condition) self.graph.add_node(n1) self.graph.add_node(n2) self.graph.add_node(n3) self.graph.add_node(n4) self.graph.add_node(n5) self.graph.add_edge(Edge(n1, n2)) self.graph.add_edge(Edge(n1, n3)) self.graph.add_edge(Edge(n1, n4)) self.graph.add_edge(Edge(n2, n5)) for st in node.if_statements: st_node = self.accept(st) self.graph.add_edge(Edge(n3, st_node)) for st in node.else_statements: st_node = self.accept(st) self.graph.add_edge(Edge(n4, st_node)) return n1 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 def accept_MaskedBinary(self, node): n1 = create_node("MaskedBinary") n2 = create_node(str(node.value)) self.graph.add_node(n1) self.graph.add_node(n2) self.graph.add_edge(Edge(n1, n2)) return n1 def accept_Ignore(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_IfExpression(self, node): n1 = create_node("IfExpression") n2 = create_node("condition") n3 = self.accept(node.condition) n4 = create_node("ifTrue") n5 = create_node("ifFalse") self.graph.add_node(n1) self.graph.add_node(n2) self.graph.add_node(n3) self.graph.add_node(n4) self.graph.add_node(n5) self.graph.add_edge(Edge(n1, n2)) self.graph.add_edge(Edge(n2, n3)) self.graph.add_edge(Edge(n1, n4)) self.graph.add_edge(Edge(n1, n5)) node_true = self.accept(node.trueValue) node_false = self.accept(node.falseValue) self.graph.add_edge(Edge(n4, node_true)) self.graph.add_edge(Edge(n5, node_false)) return n1 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 accept_Undefined(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_Unpredictable(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_See(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_ImplementationDefined(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_SubArchitectureDefined(self, node): n = create_node(str(node)) self.graph.add_node(n) return n def accept_Return(self, node): n = create_node(str(node)) self.graph.add_node(n) return n
class DependencyGraph: def __init__(self, _contract: Contract): """ Takes a Contract object and constructs the DDG for it. *** To be completed Currently cannot detect indirect read. Indirect write can be detected. """ self.contract = _contract self.node_dic = {} self.edge_dic = {} self.graph = Dot() for f in _contract.functions + _contract.constructor_as_list: if f.name in ['slitherConstructorVariables', 'slitherConstructorConstantVariables'] or not f.is_public_or_external: continue self.construct_node(f) self.construct_graph(_contract) @property def html(self): return svg_to_html(self.graph.create_svg().decode('utf-8')) def construct_graph(self, _contract): """ Constructs the graph by connecting nodes with edges. """ for f in _contract.functions + _contract.constructor_as_list: if f.name in ['slitherConstructorVariables', 'slitherConstructorConstantVariables'] or not f.is_public_or_external: continue for dependency in f.depends_on: written_f, sr = dependency[0], dependency[1] 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 update_graph(self): remaining_edges_dic = defaultdict(list) for f in self.contract.functions + self.contract.constructor_as_list: if f.name in ['slitherConstructorVariables', 'slitherConstructorConstantVariables'] or not f.is_public_or_external: continue for dependency in f.depends_on: written_f, sr = dependency[0], dependency[1] n1 = self.get_node(f.name) n2 = self.get_node(written_f.name) remaining_edges_dic[(n1, n2)].append(sr) existing_edges = self.edge_dic.keys() remaining_edges = remaining_edges_dic.keys() for ex_edge in existing_edges: if ex_edge not in remaining_edges: remove_edge(self.edge_dic[ex_edge]) # no need to check if only one state variable dependency is remove # because if a dependency between two functions is removed # all of its dependency based on whatever variable will be removed. def construct_node(self, _function: Function): """ Takes a Function object and constructs a Dot Node object for it. Adds the created object to the dictionary. Finished. """ n = Node(_function.name) n.set_tooltip(construct_tooltip(_function)) self.node_dic[_function.name] = n self.graph.add_node(n) def get_node(self, _name): return self.node_dic.get(_name) def construct_edge(self, _n1: Node, _n2: Node): """ Takes two nodes n1 depends on n2 n1 points to n2 Constructs the edge object and adds it to the dictionary. Finished. """ e = Edge(_n1, _n2, fontsize="8", fontcolor="#2E86C1", arrowsize="0.7") self.edge_dic[(_n1, _n2)] = e # e.set('color', 'green') self.graph.add_edge(e)
def main(): graph = Dot('Controller Dependency Graph') # controller node list graph.add_node( Node('amazoncloudintegration', label='AmazonCloudIntegration', shape='box')) graph.add_node(Node('apiserver', label='APIServer', shape='box')) graph.add_node( Node('applicationlayer', label='ApplicationLayer', shape='box')) graph.add_node(Node('authentication', label='Authentication', shape='box')) graph.add_node( Node( 'clusterconnection', label= '{ClusterConnection|Standalone\nManagementCluster\nManagementClusterConnection}', shape='record')) graph.add_node(Node('compliance', label='Compliance', shape='box')) graph.add_node(Node('installation', label='Installation', shape='box')) graph.add_node( Node('intrusiondetection', label='IntrusionDetection', shape='box')) graph.add_node(Node('logcollector', label='LogCollector', shape='box')) graph.add_node(Node('logstorage', label='LogStorage', shape='box')) graph.add_node(Node('manager', label='Manager', shape='box')) graph.add_node(Node('monitor', label='Monitor', shape='box')) # The controller dependencies are deduced from controller Reconcile() function. # This is still a manual process at the moment. # [AmazonCloudIntegration] -> [Installation] graph.add_edge(Edge('amazoncloudintegration', 'installation')) # [APIServer] --> [AmazonCloudIntegration] # [APIServer] --> [ClusterConnection] # [APIServer] -> [Installation] graph.add_edge( Edge('apiserver', 'amazoncloudintegration', label='amazonCRDExists', style='dashed')) graph.add_edge( Edge('apiserver', 'clusterconnection', label='TSEE', style='dashed')) graph.add_edge(Edge('apiserver', 'installation')) # [ApplicationLayer] -> [Installation] graph.add_edge(Edge('applicationlayer', 'installation')) # [Authentication] -> [ClusterConnection] # [Authentication] -> [Installation] graph.add_edge(Edge('authentication', 'clusterconnection', style='dashed')) graph.add_edge(Edge('authentication', 'installation')) # [ClusterConnection|ManagementCluster;ManagementClusterConnection] -> [Installation] graph.add_edge(Edge('clusterconnection', 'installation', style='dashed')) # [Compliance] -> [Authentication] # [Compliance] -> [ClusterConnection] # [Compliance] -> [Installation] # [Compliance] -> [LogStorage] graph.add_edge(Edge('compliance', 'authentication')) graph.add_edge(Edge('compliance', 'clusterconnection', style='dashed')) graph.add_edge(Edge('compliance', 'installation')) graph.add_edge(Edge('compliance', 'logstorage')) # [IntrusionDetection] -> [ClusterConnection] # [IntrusionDetection] -> [Installation] # [IntrusionDetection] -> [LogStorage] graph.add_edge( Edge('intrusiondetection', 'clusterconnection', style='dashed')) graph.add_edge(Edge('intrusiondetection', 'installation')) graph.add_edge(Edge('intrusiondetection', 'logstorage')) # [LogCollector] --> [ClusterConnection] # [LogCollector] -> [Installation] # [LogCollector] -> [LogStorage] graph.add_edge( Edge('logcollector', 'clusterconnection', label='AdditionalStores', style='dashed')) graph.add_edge(Edge('logcollector', 'installation')) graph.add_edge(Edge('logcollector', 'logstorage')) # [LogStorage] -> [Authentication] # [LogStorage] -> [ClusterConnection] # [LogStorage] -> [Installation] graph.add_edge(Edge('logstorage', 'authentication')) graph.add_edge(Edge('logstorage', 'clusterconnection', style='dashed')) graph.add_edge(Edge('logstorage', 'installation')) # [Manager] -> [Authentication] # [Manager] -> [ClusterConnection] # [Manager] -> [Compliance] # [Manager] -> [Installation] # [Manager] -> [LogStorage] graph.add_edge(Edge('manager', 'authentication')) graph.add_edge(Edge('manager', 'clusterconnection', style='dashed')) graph.add_edge(Edge('manager', 'compliance')) graph.add_edge(Edge('manager', 'installation')) graph.add_edge(Edge('manager', 'logstorage')) # [Monitor] -> [Authentication] graph.add_edge(Edge('monitor', 'authentication')) # [Monitor] -> [Installation] graph.add_edge(Edge('monitor', 'installation')) graph.write_svg('controller-dependency-graph.svg')
def create_graph(self, png_path): from pydot import Dot, Edge, Node graph = Dot(graph_type='digraph') graph_nodes = {} graph_edges = {} done = set() def add_node(node, expanded=False, chosen=False, in_fringe=False, in_successors=False): node_id = id(node) if node_id not in graph_nodes: label = node.state_representation() if hasattr(node, 'cost'): label += '\nCost: %s' % node.cost if hasattr(node, 'heuristic'): label += '\nHeuristic: %s' % node.heuristic if hasattr(node, 'value'): label += '\nValue: %s' % node.value new_g_node = Node(node_id, label=label, style='filled', shape='circle', fillcolor='#ffffff', fontsize=self.font_size) graph_nodes[node_id] = new_g_node g_node = graph_nodes[node_id] if expanded or chosen: g_node.set_fillcolor(self.fringe_color) if in_fringe: g_node.set_color(self.fringe_color) g_node.set_penwidth(3) if in_successors: g_node.set_color(self.successor_color) g_node.set_fontcolor(self.successor_color) return g_node 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 if self.last_event == 'chosen_node': add_node(self.last_chosen, chosen=True) if self.last_event == 'expanded': for node, successors in zip(self.last_expandeds, self.last_successors): add_node(node, expanded=True) for successor_node in successors: add_edge_to_parent(successor_node, is_successor=True, parent=node) for node in self.current_fringe: add_node(node, in_fringe=True) while node is not None and node not in done: if node.parent is not None: add_edge_to_parent(node) else: add_node(node) done.add(node) node = node.parent for node_id in sorted(graph_nodes.keys()): graph.add_node(graph_nodes[node_id]) for node_id, parent_id in sorted(graph_edges.keys()): graph.add_edge(graph_edges[node_id, parent_id]) graph.write_png(png_path)
def save_ex(self, filename, print_ir=False, format='dot'): """Save basic block graph into a file. """ fontname = 'Ubuntu Mono' # fontname = 'DejaVu Sans Mono' # fontname = 'DejaVu Sans Condensed' # fontname = 'DejaVu Sans Light' # fontname = 'Liberation Mono' # fontname = 'DejaVu Serif Condensed' # fontname = 'Ubuntu Condensed' graph_format = { 'graph_type': 'digraph', 'nodesep': 1.2, 'rankdir': 'TB', 'splines': 'ortho', } node_format_base = { 'fontname': fontname, 'fontsize': 9.0, 'penwidth': 0.5, 'rankdir': 'LR', 'shape': 'plaintext', } node_format_entry = { 'pencolor': 'orange', } node_format_exit = { 'pencolor': 'gray', } node_format_entry_exit = { 'pencolor': 'gray', } edge_format = { 'arrowhead': 'vee', 'arrowsize': 0.6, 'fontname': fontname, 'fontsize': 8.0, 'penwidth': 0.5, } edge_colors = { 'direct': 'blue', 'not-taken': 'red', 'taken': 'darkgreen', } try: dot_graph = Dot(**graph_format) # add nodes nodes = {} for bb_addr in self._graph.node.keys(): # Skip jmp/jcc to sub routines. if not bb_addr in self._bb_by_addr: continue bb_dump = self._dump_bb_ex(self._bb_by_addr[bb_addr], print_ir) if self._bb_by_addr[bb_addr].is_entry and not self._bb_by_addr[ bb_addr].is_exit: node_format = dict(node_format_base, **node_format_entry) elif self._bb_by_addr[bb_addr].is_exit and not self._bb_by_addr[ bb_addr].is_entry: node_format = dict(node_format_base, **node_format_exit) elif self._bb_by_addr[bb_addr].is_entry and self._bb_by_addr[ bb_addr].is_exit: node_format = dict(node_format_base, **node_format_entry_exit) else: node_format = dict(node_format_base) if self._bb_by_addr[bb_addr].is_entry: bb_label = "{} @ {:x}".format(self._name, bb_addr) else: bb_label = "loc_{:x}".format(bb_addr) label = '<' label += '<table border="1.0" cellborder="0" cellspacing="1" cellpadding="0" valign="middle">' label += ' <tr><td align="center" cellpadding="1" port="enter"></td></tr>' label += ' <tr><td align="left" cellspacing="1">{label}</td></tr>' label += ' {assembly}' label += ' <tr><td align="center" cellpadding="1" port="exit" ></td></tr>' label += '</table>' label += '>' label = label.format(label=bb_label, assembly=bb_dump) nodes[bb_addr] = Node(bb_addr, label=label, **node_format) dot_graph.add_node(nodes[bb_addr]) # add edges for bb_src_addr in self._graph.node.keys(): # Skip jmp/jcc to sub routines. if not bb_src_addr in self._bb_by_addr: continue for bb_dst_addr, branch_type in self._bb_by_addr[ bb_src_addr].branches: # Skip jmp/jcc to sub routines. if not bb_dst_addr in self._bb_by_addr: continue dot_graph.add_edge( Edge(nodes[bb_src_addr], nodes[bb_dst_addr], color=edge_colors[branch_type], **edge_format)) # Save graph. dot_graph.write("{}.{}".format(filename, format), format=format) except Exception as err: logger.error("Failed to save basic block graph: %s (%s)", filename, format, exc_info=True)
# node3 = Node("c"); # edge1 = Edge(node1, node2) # edge2 = Edge(node2, node3) # edge3 = Edge(node1, node3) # graph.add_edge(edge1) # graph.add_edge(edge2) # graph.add_edge(edge3) # graph.write_png("primer1_graph.png") graph = Dot(graph_type = "digraph", rankdir = "BT") graph.set_node_defaults(style = "filled", fillcolor = "grey") node1 = Node("Nastavnik", color = "green") node2 = Node("Student", color = "blue") node1.set("shape", "record") graph.add_node(node1) graph.add_node(node2) edge1 = Edge(node1, node2, label = "Predaje", color = "red") graph.add_edge(edge1) graph.write_png("primer2_graph.png") #Zadatak graph = Dot(graph_type = "digraph", rankdir = "BT") graph.set_node_defaults(shape = "record") teacher = Node("Teacher", label = "{Nastavnik|+ime:String \n+prezime:String|\n}") course = Node("Course", label = "{Kurs|\n|\n}") student = Node("Student", label = "{Student|\n|\n}") lesson = Node("Lesson", label = "{Predavanja|\n|\n}") tutorial = Node("Tutorial", label = "{Konsultacije|\n |\n}") assessment = Node("Assessment", label = "{Ocenjivanje|\n|\n}") coursework = Node("Coursework", label = "{Predispitne obaveze|\n|\n}")
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:
def save_ex(self, filename, print_ir=False, format='dot'): """Save basic block graph into a file. """ fontname = 'Ubuntu Mono' # fontname = 'DejaVu Sans Mono' # fontname = 'DejaVu Sans Condensed' # fontname = 'DejaVu Sans Light' # fontname = 'Liberation Mono' # fontname = 'DejaVu Serif Condensed' # fontname = 'Ubuntu Condensed' graph_format = { 'graph_type' : 'digraph', 'nodesep' : 1.2, 'rankdir' : 'TB', 'splines' : 'ortho', } node_format_base = { 'fontname' : fontname, 'fontsize' : 9.0, 'penwidth' : 0.5, 'rankdir' : 'LR', 'shape' : 'plaintext', } node_format_entry = { 'pencolor' : 'orange', } node_format_exit = { 'pencolor' : 'gray', } node_format_entry_exit = { 'pencolor' : 'gray', } edge_format = { 'arrowhead' : 'vee', 'arrowsize' : 0.6, 'fontname' : fontname, 'fontsize' : 8.0, 'penwidth' : 0.5, } edge_colors = { 'direct' : 'blue', 'not-taken' : 'red', 'taken' : 'darkgreen', } try: dot_graph = Dot(**graph_format) # add nodes nodes = {} for bb_addr in self._graph.node.keys(): # Skip jmp/jcc to sub routines. if not bb_addr in self._bb_by_addr: continue bb_dump = self._dump_bb_ex(self._bb_by_addr[bb_addr], print_ir) if self._bb_by_addr[bb_addr].is_entry and not self._bb_by_addr[bb_addr].is_exit: node_format = dict(node_format_base, **node_format_entry) elif self._bb_by_addr[bb_addr].is_exit and not self._bb_by_addr[bb_addr].is_entry: node_format = dict(node_format_base, **node_format_exit) elif self._bb_by_addr[bb_addr].is_entry and self._bb_by_addr[bb_addr].is_exit: node_format = dict(node_format_base, **node_format_entry_exit) else: node_format = dict(node_format_base) if self._bb_by_addr[bb_addr].is_entry: bb_label = "{} @ {:x}".format(self._name, bb_addr) else: bb_label = "loc_{:x}".format(bb_addr) label = '<' label += '<table border="1.0" cellborder="0" cellspacing="1" cellpadding="0" valign="middle">' label += ' <tr><td align="center" cellpadding="1" port="enter"></td></tr>' label += ' <tr><td align="left" cellspacing="1">{label}</td></tr>' label += ' {assembly}' label += ' <tr><td align="center" cellpadding="1" port="exit" ></td></tr>' label += '</table>' label += '>' label = label.format(label=bb_label, assembly=bb_dump) nodes[bb_addr] = Node(bb_addr, label=label, **node_format) dot_graph.add_node(nodes[bb_addr]) # add edges for bb_src_addr in self._graph.node.keys(): # Skip jmp/jcc to sub routines. if not bb_src_addr in self._bb_by_addr: continue for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches: # Skip jmp/jcc to sub routines. if not bb_dst_addr in self._bb_by_addr: continue dot_graph.add_edge( Edge(nodes[bb_src_addr], nodes[bb_dst_addr], color=edge_colors[branch_type], **edge_format)) # Save graph. dot_graph.write("{}.{}".format(filename, format), format=format) except Exception as err: logger.error( "Failed to save basic block graph: %s (%s)", filename, format, exc_info=True )
def renderProof(self, proof, nsMap={}): """ Takes an instance of a compiled ProofTree and a namespace mapping (for constructing QNames for rule pattern terms) and returns a BGL Digraph instance representing the Proof Tree """ try: import boost.graph as bgl bglGraph = bgl.Digraph() except: try: from pydot import Node, Edge, Dot dot = Dot(graph_type='digraph') except: raise NotImplementedError("No graph libraries") namespace_manager = NamespaceManager(Graph()) vertexMaps = {} edgeMaps = {} # for prefix,uri in nsMap.items(): # namespace_manager.bind(prefix, uri, override=False) visitedNodes = {} edges = [] idx = 0 #register the step nodes for nodeset in self.goals.values(): if not nodeset in visitedNodes: idx += 1 visitedNodes[nodeset] = nodeset.generateGraphNode( str(idx), nodeset is proof) #register the justification steps for justification in nodeset.steps: if not justification in visitedNodes: idx += 1 visitedNodes[ justification] = justification.generateGraphNode( str(idx)) for ant in justification.antecedents: if ant not in visitedNodes: idx += 1 visitedNodes[ant] = ant.generateGraphNode(str(idx)) for node in visitedNodes.values(): dot.add_node(node) for nodeset in self.goals.values(): for justification in nodeset.steps: edge = Edge(visitedNodes[nodeset], visitedNodes[justification], label="is the consequence of", color='red') dot.add_edge(edge) for ant in justification.antecedents: if justification.source: edge = Edge(visitedNodes[ant.steps[0]], visitedNodes[nodeset], label="has antecedent", color='blue') dot.add_edge(edge) else: #not isinstance(justification,InferenceStep) or not justification.source:#(visitedNodes[nodeset],visitedNodes[justification]) not in edges: edge = Edge(visitedNodes[justification], visitedNodes[ant], label="has antecedent", color='blue') #edge.label="has antecedents" dot.add_edge(edge) #edges.append((visitedNodes[nodeset],visitedNodes[justification])) return dot #bglGraph
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', } html_entities = { "!" : "!", "#" : "#", ":" : ":", "{" : "{", "}" : "}", } try: dot_graph = Dot(graph_type="digraph", rankdir="TB") # Add nodes. nodes = {} for bb_addr in self._bb_by_addr: bb_dump = self._dump_bb(self._bb_by_addr[bb_addr], print_ir) # html-encode colon character for char, encoding in html_entities.items(): bb_dump = bb_dump.replace(char, encoding) label = "{{<f0> {:#010x} | {}}}".format(bb_addr, bb_dump) nodes[bb_addr] = Node(bb_addr, label=label, **node_format) dot_graph.add_node(nodes[bb_addr]) # Add edges. for bb_src_addr in self._bb_by_addr: for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches: # Skip jmp/jcc to sub routines. if not bb_dst_addr in self._bb_by_addr: continue dot_graph.add_edge( Edge( nodes[bb_src_addr], nodes[bb_dst_addr], color=edge_colors[branch_type], **edge_format)) # 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 )
class Grafo(): def __init__(self, rotulo): self.__rotulo = rotulo self.__grafoTela = Dot(graph_type='graph') self.__vertices = list() self.__arestas = list() def getRotulo(self): return self.__rotulo def setRotulo(self, rotulo): self.__rotulo = rotulo def criarVertice(self, nome): vertice = Vertice(nome) self.__vertices.append(vertice) self.__grafoTela.add_node(vertice.getVertice()) def criarVerticeComCoordenadas(self, nome, cx, cy): vertice = Vertice(nome) vertice.InserirCoordenadas(cx, cy) self.__vertices.append(vertice) self.__grafoTela.add_node(vertice.getVertice()) def getVertices(self): return self.__vertices def getArestas(self): return self.__arestas def inserirAresta(self, nome, custo, vertice1, vertice2): for i in self.__vertices: if i.getNome() == vertice1: aux = i elif i.getNome() == vertice2: aux1 = i aresta = Aresta(nome, custo, aux, aux1) aux.setAdjacente(aux1) aux1.setAdjacente(aux) self.__grafoTela.add_edge(aresta.getAresta()) self.__arestas.append(aresta) def removerVertice(self, vertice): conta = 0 for i in self.__arestas: if i.getVertice1().getNome() == vertice: aux = i.getVertice2() contv = 0 for j in aux.getLista(): if j.getNome() == vertice: aux.getLista().pop(contv) contv += 1 self.__arestas.pop(conta) elif i.getVertice2().getNome() == vertice: aux = i.getVertice1() contv = 0 for j in aux.getLista(): if j.getNome() == vertice: aux.getLista().pop(contv) contv += 1 self.__arestas.pop(conta) conta += 1 conta = 0 for i in self.__vertices: if i.getNome() == vertice: self.__vertices.pop(conta) break conta += 1 def removerAresta(self, nome): conta = 0 for i in self.__arestas: if i.getNome() == nome: self.__arestas.pop(conta) break conta += 1 def verificarAdjacente(self, vertice1, vertice2): for i in self.__vertices: if i.getNome() == vertice1: for j in i.getLista(): if j.getNome() == vertice2: return True elif i.getNome() == vertice2: for j in i.getLista(): if j.getNome() == vertice1: return True return False def pegarCustoAresta(self, nome): for i in self.__arestas: if i.getNome() == nome: return i.getCusto() def retornarExtremosAresta(self, nome): for i in self.__arestas: if i.getNome() == nome: return i.getVertices() def exibirGrafo(self): l = [] print(self.__rotulo) for i in self.__arestas: l = i.getVertices() aux2 = l.pop() aux1 = l.pop() l.append(aux1.getNome()) l.append(i.getNome()) l.append(str(i.getCusto())) l.append(aux2.getNome()) concat = ''.join(l) print(concat) def showGrafoTela(self): l = [] for i in self.__arestas: l = i.getVertices() aux2 = l.pop() aux1 = l.pop() l.append(aux1.getNome()) l.append(i.getNome()) l.append(str(i.getCusto())) l.append(aux2.getNome()) concat = ''.join(l) print(concat) def carregarImagem(self): self.__grafoTela.write_png(Config.DIRETORIO_PADRAO_IMAGEM) def BuscaEmLargura(self, vsaida, vertice): visitados = list() fila = list() fila.append(vsaida) visitados.append(vsaida) while len(visitados) != len(self.__vertices) or len(fila) != 0: print(len(fila)) for i in self.__vertices: if i.getNome() == fila[0]: aux = i.getLista() for j in aux: if j.getNome() == vertice: return j elif j.getNome() not in visitados: visitados.append(j.getNome()) fila.append(j.getNome()) fila.pop(0) print('vertice não encontrado') def BuscaEmProfundidade(self, vsaida, vertice): visitados = list() pilha = list() cont = 0 tamanho = len(self.__arestas) continuar = True visitados.append(vsaida) pilha.append(vsaida) while len(visitados) != len(self.__vertices) or len(pilha) != 0: cont = 0 continuar = True i = self.__arestas[0] while cont < tamanho and continuar == True: while (i.getVertice1().getNome() != pilha[-1]) and (i.getVertice2().getNome() != pilha[-1]): if cont >= (tamanho - 1): break else: i = self.__arestas[cont] cont += 1 cont += 1 if i.getVertice1().getNome() == pilha[-1]: if i.getVertice2().getNome() not in visitados: visitados.append(i.getVertice2().getNome()) pilha.append(i.getVertice2().getNome()) continuar = False else: i = self.__arestas[cont] elif i.getVertice2().getNome() == pilha[-1]: if i.getVertice1().getNome() not in visitados: visitados.append(i.getVertice1().getNome()) pilha.append(i.getVertice1().getNome()) continuar = False else: i = self.__arestas[cont] elif cont >= tamanho: continuar = False pilha.pop(len(pilha) - 1) if visitados[-1] == vertice: if i.getVertice1().getNome() == vertice: return i.getVertice1() else: return i.getVertice2() print('vertice não encontrado') def GerarArvoreMinima(self, vsaida): arvore = Grafo('Arvore Minima') arvore.criarVertice(vsaida) aresta = self.__arestas[0] menor = None aux = arvore.getVertices() verticev = [] verticev.append(aux[len(aux) - 1].getNome()) while len(aux) < len(self.__vertices): for j in aux: for i in self.__arestas: if i.getVertice1().getNome() == j.getNome( ) or i.getVertice2().getNome() == j.getNome(): if i.getVertice1( ).getNome() not in verticev or i.getVertice2().getNome( ) not in verticev: if menor == None: menor = i.getCusto() aresta = i elif i.getCusto() < menor: menor = i.getCusto() aresta = i if aresta.getVertice1().getNome() not in verticev: print('if vertice 1') arvore.criarVertice(aresta.getVertice1().getNome()) else: print('if vertice 2') arvore.criarVertice(aresta.getVertice2().getNome()) aux = arvore.getVertices() verticev.append(aux[len(aux) - 1]) arvore.inserirAresta(aresta.getNome(), aresta.getCusto(), aresta.getVertice1().getNome(), aresta.getVertice2().getNome()) menor = None return arvore def grafoConvexoEhPlanar(self): qtdeArestas = len(self.__arestas) qtdeVertices = len(self.__vertices) total = 0 print("Vertices: ", qtdeVertices) print("Arestas: ", qtdeArestas) if qtdeVertices >= 3: total = 3 * qtdeVertices - 6 print("Total 1: ", total) if not qtdeArestas <= total: print("condicao1") return False if not self.temCiclosDeComprimentoTres(): total = 2 * qtdeVertices - 4 print("Total 2: ", total) if not qtdeArestas <= total: print("condicao2") return False return True else: return False def temCiclosDeComprimentoTres(self): for vertice in self.__vertices: for adjacente in vertice.getLista(): for adjacenteRetorno in adjacente.getLista(): if self.verificarAdjacente(vertice.getNome(), adjacenteRetorno.getNome()): return True return False def coloreVertices(self): listaVertices = list() grauVertices = list() numeracaoCores = list() numeroCor = -1 for i in self.__vertices: listaVertices.append(i.getNome()) grauVertices.append(0) numeracaoCores.append(-1) for i in self.__arestas: v1 = i.getVertice1() v2 = i.getVertice2() index = listaVertices.index(v1.getNome()) grauVertices[index] = grauVertices[index] + 1 index = listaVertices.index(v2.getNome()) grauVertices[index] = grauVertices[index] + 1 for i in range(1, len(listaVertices)): for j in range(0, i): if (grauVertices[i] > grauVertices[j]): aux = listaVertices[i] temp = grauVertices[i] listaVertices[i] = listaVertices[j] grauVertices[i] = grauVertices[j] listaVertices[j] = aux grauVertices[j] = temp for i in range(0, len(listaVertices)): if (numeracaoCores[i] == -1): numeroCor = numeroCor + 1 numeracaoCores[i] = numeroCor if (i + 1 < len(listaVertices)): for j in range(i + 1, len(listaVertices)): if (numeracaoCores[j] == -1): if not (self.verificarAdjacente( listaVertices[i], listaVertices[j])): numeracaoCores[j] = numeroCor for i in range(0, len(listaVertices)): print('Vertice : ') print(listaVertices[i]) print('Grau : ') print(grauVertices[i]) print('Cor : ') print(numeracaoCores[i]) #azul-claro rosa verde marrom cores = list() #"#00c6c5", "#cc0132", "#538e6d", "#843907" # cores.append("#00c6c5") # cores.append("#cc0132") # cores.append("#538e6d") # cores.append("#843907") # pos = 0 # for vertice in self.__vertices: # vertice.setVertice(cores[pos]) # pos += 1 # for adjacente in vertice.getLista(): # for adjacenteDoAdjacente in adjacente.getLista(): # vertice.setVertice(cores[pos]) # pos += 1 # if pos >= 4: # pos = 0 def Dijkstra(self, vsaida, vchegada): fechados = list() estimativa = list() precedente = list() listaVertices = list() menor = -1 selecionado = "" contador = len(self.__vertices) for i in self.__vertices: listaVertices.append(i.getNome()) if (i.getNome() == vsaida): estimativa.append(0) precedente.append('') else: estimativa.append(-1) precedente.append('') for j in range(0, contador): for i in range(0, contador): if (listaVertices[i] not in fechados): if (menor == -1): menor = estimativa[i] selecionado = listaVertices[i] elif (estimativa[i] < menor and estimativa[i] > -1): menor = estimativa[i] selecionado = listaVertices[i] fechados.append(selecionado) menor = -1 for k in self.__arestas: if (k.getVertice1().getNome() not in fechados and k.getVertice2().getNome() == selecionado): custo = k.getCusto() indexAdjacente = listaVertices.index( k.getVertice1().getNome()) indexAtual = listaVertices.index(selecionado) if (estimativa[indexAdjacente] == -1): estimativa[indexAdjacente] = custo precedente[indexAdjacente] = selecionado else: custo = custo + estimativa[indexAtual] if (custo < estimativa[indexAdjacente]): estimativa[indexAdjacente] = custo precedente[indexAdjacente] = selecionado elif (k.getVertice1().getNome() == selecionado and k.getVertice2().getNome() not in fechados): custo = k.getCusto() indexAdjacente = listaVertices.index( k.getVertice2().getNome()) indexAtual = listaVertices.index(selecionado) if (estimativa[indexAdjacente] == -1): estimativa[indexAdjacente] = custo precedente[indexAdjacente] = selecionado else: custo = custo + estimativa[indexAtual] if (custo < estimativa[indexAdjacente]): estimativa[indexAdjacente] = custo precedente[indexAdjacente] = selecionado for i in range(0, len(listaVertices)): print(listaVertices[i]) print(estimativa[i]) print(precedente[i]) def AEstrela(self, vsaida, vchegada): distanciaLinhaReta = list() ordemLista = list() cobjetivo = list() proximo = vsaida aproximacoes = list() nodos = list() calculoDeslocamento = list() distancia = 0 continua = True grafo = Grafo('A*') for i in self.__arestas: if (i.getCusto() == 0): v1 = i.getVertice1() v2 = i.getVertice2() c1 = v1.getCoordenadas() c2 = v2.getCoordenadas() custo = abs(c1[0] - c2[0]) + abs(c1[1] - c2[1]) i.setCusto(custo) for i in self.__vertices: if (i.getNome() == vchegada): aux = i.getCoordenadas() cobjetivo.append(aux[0]) cobjetivo.append(aux[1]) for i in self.__vertices: aux = i.getCoordenadas() distancia = abs(cobjetivo[0] - aux[0]) + abs(cobjetivo[1] - aux[1]) distanciaLinhaReta.append(distancia) ordemLista.append(i.getNome()) #ordemCidadesLista# grafo.criarVertice(proximo) while (continua): for i in self.__arestas: if (i.getVertice1().getNome() == proximo): aproximacoes.append(i.getCusto()) nodos.append(i.getVertice2().getNome()) elif (i.getVertice2().getNome() == proximo): aproximacoes.append(i.getCusto()) nodos.append(i.getVertice1().getNome()) contador = len(aproximacoes) for i in range(0, contador): index = ordemLista.index(nodos[i]) aux = distancia + aproximacoes[i] + distanciaLinhaReta[index] calculoDeslocamento.append(aux) aux = min(calculoDeslocamento) index = calculoDeslocamento.index(aux) grafo.criarVertice(nodos[index]) grafo.inserirAresta('------', aproximacoes[index], proximo, nodos[index]) distancia = distancia + aproximacoes[index] proximo = nodos[index] if (proximo == vchegada): continua = False aproximacoes.clear() nodos.clear() calculoDeslocamento.clear() return grafo
def generate_dot_from_schema(metadata, name=None): graph = Dot( name or 'Database schema', splines='true', rankdir='LR', ) graph.add_node(Node( 'Description', shape='box', label=('<' 'PK: Primary key<br />' 'FK: Foreign key<br />' 'UQ: Unique constraint<br />' '>'), )) for table_name, table in metadata.tables.items(): soup = BeautifulSoup(f''' <table border="0" cellspacing="0" cellborder="1"> <tr> <td colspan="3" bgcolor="lightblue"> <font>{table_name}</font> </td> </tr> </table> ''', 'html.parser') for column_name, column in table.columns.items(): special = set() if column.unique: special.add('UQ') if column.primary_key: special.add('PK') if column.index: special.add('IX') if column.foreign_keys: special.add('FK') row_soup = BeautifulSoup(f''' <tr> <td port="{column_name}_in"> <font>{','.join(special) if special else ' '}</font> </td> <td> <font>{column_name}</font> </td> <td port="{column_name}_out"> <font>{str(column.type)}{'*' if column.nullable else ''}</font> </td> </tr> ''', 'html.parser') soup.table.append(row_soup.tr) # Add edges for fk in column.foreign_keys: edge = Edge( f'{table_name}:{column_name}_out:e', f'{fk.column.table.name}:{fk.column.name}_in:w', ) graph.add_edge(edge) node = Node( table_name, label=f'<{str(soup.table)}>', shape='none', dir='back', arrowhead='dot', arrowtail='crow', ) graph.add_node(node) return graph
def save_ex(self, filename, print_ir=False, format='dot'): """Save basic block graph into a file. """ fontname = 'Ubuntu Mono' # fontname = 'DejaVu Sans Mono' # fontname = 'DejaVu Sans Condensed' # fontname = 'DejaVu Sans Light' # fontname = 'Liberation Mono' # fontname = 'DejaVu Serif Condensed' # fontname = 'Ubuntu Condensed' node_format = { 'shape' : 'plaintext', 'rankdir' : 'LR', 'fontname' : fontname, 'fontsize' : 9.0, 'penwidth' : 0.5, # 'style' : 'filled', # 'fillcolor' : 'orange', } edge_format = { 'fontname' : fontname, 'fontsize' : 8.0, 'penwidth' : 0.5, 'arrowsize' : 0.6, 'arrowhead' : 'vee', } edge_colors = { 'taken' : 'darkgreen', '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", splines="ortho", nodesep=1.2) # add nodes nodes = {} for bb_addr in gr.node.keys(): # Skip jmp/jcc to sub routines. if not bb_addr in self._bb_by_addr: continue dump = self._dump_bb_ex(self._bb_by_addr[bb_addr], print_ir) label = '<' label += '<table border="1.0" cellborder="0" cellspacing="1" cellpadding="0" valign="middle">' label += ' <tr><td align="center" cellpadding="1" port="enter"></td></tr>' if self._bb_by_addr[bb_addr].label: label += ' <tr><td align="left" cellspacing="1">{}</td></tr>'.format(self._bb_by_addr[bb_addr].label) else: label += ' <tr><td align="left" cellspacing="1">loc_{address:x}</td></tr>' label += ' {assembly}' label += ' <tr><td align="center" cellpadding="1" port="exit" ></td></tr>' label += '</table>' label += '>' if self._bb_by_addr[bb_addr].is_entry: node_format['style'] = 'filled' node_format['fillcolor'] = 'orange' label = label.format(address=bb_addr, assembly=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(): # Skip jmp/jcc to sub routines. if not bb_src_addr in self._bb_by_addr: continue for bb_dst_addr, branch_type in self._bb_by_addr[bb_src_addr].branches: # Skip jmp/jcc to sub routines. if not bb_dst_addr in self._bb_by_addr: continue graph.add_edge( Edge(nodes[bb_src_addr], nodes[bb_dst_addr], color=edge_colors[branch_type], **edge_format)) graph.write("%s_%03d.%s" % (filename, idx, format), format=format) except Exception as err: logger.error( "Failed to save basic block graph: %s (%s)", filename, format, exc_info=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', } html_entities = { "!": "!", "#": "#", ":": ":", "{": "{", "}": "}", } try: dot_graph = Dot(graph_type="digraph", rankdir="TB") # Add nodes. nodes = {} for bb_addr in self._bb_by_addr: bb_dump = self._dump_bb(self._bb_by_addr[bb_addr], print_ir) # html-encode colon character for char, encoding in html_entities.items(): bb_dump = bb_dump.replace(char, encoding) label = "{{<f0> {:#08x} | {}}}".format(bb_addr, bb_dump) nodes[bb_addr] = Node(bb_addr, label=label, **node_format) dot_graph.add_node(nodes[bb_addr]) # Add edges. for bb_src_addr in self._bb_by_addr: for bb_dst_addr, branch_type in self._bb_by_addr[ bb_src_addr].branches: # Skip jmp/jcc to sub routines. if not bb_dst_addr in self._bb_by_addr: continue dot_graph.add_edge( Edge(nodes[bb_src_addr], nodes[bb_dst_addr], color=edge_colors[branch_type], **edge_format)) # 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 visualize(self, filename): """Save a graphical representation of this AF.""" graph = Dot(graph_type='digraph') for arg in self.arg_f: # Fixed arguments 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, style="filled", fillcolor=cf.COLOR_FIXED)) for arg in self.arg_u: # Uncertain arguments graph.add_node( Node(name=arg.text, style="filled", fillcolor=cf.COLOR_UNCERTAIN)) for arg in self.arg_c: # Control arguments graph.add_node( Node(name=arg.text, style="filled", fillcolor=cf.COLOR_CONTROL)) for att in self.att_f: # Fixed attacks if att.arg_start in self.arg_f | self.arg_u and \ att.arg_end in self.arg_f | self.arg_u: 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}]" graph.add_edge( Edge(texts[0], texts[1], color=cf.COLOR_FIXED, dirType="forward")) else: print("Warning: attack in CAF but not its start or end") for att in self.att_u: # Uncertain attacks if att.arg_start in self.arg_f | self.arg_u and \ att.arg_end in self.arg_f | self.arg_u: 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}]" graph.add_edge( Edge(texts[0], texts[1], color=cf.COLOR_UNCERTAIN, dirType="both", style="dashed")) else: print("Warning: attack in CAF but not its start or end") for att in self.att_b: # Bidirectional attacks if att.arg_start in self.arg_f | self.arg_u and \ att.arg_end in self.arg_f | self.arg_u: 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}]" graph.add_edge( Edge(texts[0], texts[1], color=cf.COLOR_UNCERTAIN, dirType="forward")) else: print("Warning: attack in CAF but not its start or end") for att in self.att_c: # Control attacks if att.arg_start in self.arg_c and \ att.arg_end in self.arg_c | self.arg_f | self.arg_u: 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}]" graph.add_edge( Edge(texts[0], texts[1], color=cf.COLOR_CONTROL, dirType="forward")) else: print("Warning: attack in CAF but not its start or end") graph.write_png(filename)
def unflat(angr_proj, barf_proj, function): ''' Given the angr proejct and its function address, unflat the cfg Args: angr_proj : angr project barf_proj : barf project fucntion: the analysed function Returns: ''' #prelogue_block = None address = function.addr f_cfg = barf_proj.recover_cfg(start = address) blocks_list = f_cfg.basic_blocks prelogue_block = f_cfg.find_basic_block(address) try: main_dispatcher = prelogue_block.direct_branch except: return exit_blocks = list() normal_blocks = list() nop_blocks = list() predispatcher_address = 0 ### First, need find the predispatcher for temp_block in blocks_list: if temp_block.direct_branch == main_dispatcher: predispatcher_address = temp_block.start_address elif len(temp_block.branches) == 0 and temp_block.direct_branch == None: exit_blocks.append(temp_block.start_address) ### End find the predispatcher ### Specify the normal blocks and nop blocks for temp_block in blocks_list: if temp_block.direct_branch == predispatcher_address and len(temp_block.instrs) != 1: normal_blocks.append(temp_block.start_address) elif temp_block.start_address != address and temp_block.start_address not in exit_blocks: nop_blocks.append(temp_block) ### End specify the blocks if len(normal_blocks) == 0: print("The function %s don't be obfuscated" % function.name) return ## Symbolic execution to find the blocks' sequence print(len(normal_blocks)) normal_blocks.append(address) global normal_exit_blocks normal_exit_blocks = copy.deepcopy(normal_blocks) normal_exit_blocks.extend(exit_blocks) relationships = dict() patch_instrs = dict() for temp_block in normal_exit_blocks: relationships[temp_block] = list() for temp_start in normal_blocks: temp_block = f_cfg.find_basic_block(temp_start) branches = False #hook = list() for inst in temp_block.instrs: if inst.asm_instr.mnemonic.startswith('cmov'): patch_instrs[temp_start] = inst.asm_instr branches = True #elif inst.asm_instr.mnemonic.startswith('call'): # hook.append(inst.addr) if branches: ##if it has branches, we should traverse the every branch relationships[temp_start].append(symbolic_compute(angr_proj, temp_start, claripy.BVV(1, 1), True)) relationships[temp_start].append(symbolic_compute(angr_proj, temp_start, claripy.BVV(0, 1), True)) else: relationships[temp_start].append(symbolic_compute(angr_proj, temp_start)) ###End get the basic block relationships f_cfg.save(function.name+"_origin", format = "png") ###output the dot graph dot_graph = Dot(function.name+".dot") node_color = { 'entry': 'orange', 'exit': 'gray', 'other': 'black', } node_format = { 'fontname': 'monospace', 'fontsize': 9.0, 'penwidth': 0.5, 'rankdir': 'LR', 'shape': 'plaintext', } nodes = {} bb_tpl = '<' bb_tpl += '<table border="1.0" cellborder="0" cellspacing="1" cellpadding="0" valign="middle">' bb_tpl += ' <tr><td align="center" cellpadding="1" port="enter"></td></tr>' bb_tpl += ' <tr><td align="left" cellspacing="1">{label}</td></tr>' bb_tpl += ' {assembly}' bb_tpl += ' <tr><td align="center" cellpadding="1" port="exit" ></td></tr>' bb_tpl += '</table>' bb_tpl += '>' for node_address, node_list in relationships.items(): temp_block = f_cfg.find_basic_block(node_address) asm_mnemonic_max_width = bb_get_instr_max_width(temp_block) + 1 lines = list() if len(node_list) == 1: for dinstr in temp_block: dinstr = dinstr.asm_instr if dinstr.mnemonic.startswith('jmp'): origin_str = 'jmp ' + (' ' * (asm_mnemonic_max_width - len(dinstr.mnemonic))) + hex(node_list[0]) else: oprnds_str = ", ".join([oprnd.to_string() for oprnd in dinstr.operands]) origin_str = dinstr.mnemonic + (' ' * (asm_mnemonic_max_width - len(dinstr.mnemonic))) origin_str += " " + oprnds_str if oprnds_str else "" lines.append(render_asm(origin_str, dinstr.address)) elif len(node_list) == 2: for dinstr in temp_block: dinstr = dinstr.asm_instr if dinstr.mnemonic.startswith('cmov'): origin_str = 'j' + dinstr.mnemonic[4:] origin_str += (' ' * (asm_mnemonic_max_width - len(origin_str))) origin_str += ' ' + hex(node_list[0]) lines.append(render_asm(origin_str, dinstr.address)) origin_str = 'jmp' origin_str += (' ' * (asm_mnemonic_max_width - len(origin_str))) origin_str += hex(node_list[1]) lines.append(render_asm(origin_str, dinstr.address)) break else: oprnds_str = ", ".join([oprnd.to_string() for oprnd in dinstr.operands]) origin_str = dinstr.mnemonic + (' ' * (asm_mnemonic_max_width - len(dinstr.mnemonic))) origin_str += " " + oprnds_str if oprnds_str else "" lines.append(render_asm(origin_str, dinstr.address)) else: for dinstr in temp_block: dinstr = dinstr.asm_instr oprnds_str = ", ".join([oprnd.to_string() for oprnd in dinstr.operands]) origin_str = dinstr.mnemonic + (' ' * (asm_mnemonic_max_width - len(dinstr.mnemonic))) origin_str += " " + oprnds_str if oprnds_str else "" lines.append(render_asm(origin_str, dinstr.address)) bb_dump = "".join(lines) bb_addr = temp_block.address if temp_block.is_entry: bb_label = "{} @ {:x}".format(function.name, bb_addr) else: bb_label = "loc_{:x}".format(bb_addr) bb_formated = bb_tpl.format(label=bb_label, assembly=bb_dump) if temp_block.is_entry: bb_type = "entry" elif node_address in exit_blocks: bb_type = "exit" else: bb_type = "other" created_node = Node(temp_block.address, label = bb_formated, color = node_color[bb_type], **node_format) nodes[node_address] = created_node dot_graph.add_node(created_node) ###End write node ###Write Edge for node_address, node_list in relationships.items(): if len(node_list) == 1: created_edge = Edge(nodes[node_address], nodes[node_list[0]], color = 'blue') dot_graph.add_edge(created_edge) elif len(node_list) == 2: created_edge = Edge(nodes[node_address], nodes[node_list[0]], color = 'darkgreen') dot_graph.add_edge(created_edge) created_edge = Edge(nodes[node_address], nodes[node_list[1]], color = 'red') dot_graph.add_edge(created_edge) ###End write edge dot_graph.write_png(function.name+"_unflat.png")
#exit() for entity in activities.keys(): graph.add_node(Activity(entity, activities[entity])) for entity in entities.keys(): labels = [] if "prov:type" in entities[entity]: labels.append(entities[entity]["prov:type"]) if "prov:label" in entities[entity]: labels.append(entities[entity]["prov:label"]) dot.add_node(pydot.Node(entity, label = "|".join(labels), shape = "box")) graph.add_node(Entity(entity, entities[entity])) for entity in derived.keys(): #print "COMPARE this " + entity + " vs " + derived[entity]["prov:generatedEntity"] dot.add_edge(pydot.Edge(derived[entity]["prov:usedEntity"], derived[entity]["prov:generatedEntity"], label="DERIVED: " + derived[entity]["prov:label"])) graph.add_edge(Derived(graph.node_named(derived[entity]["prov:usedEntity"]), graph.node_named(derived[entity]["prov:generatedEntity"]), derived[entity])) for entity in generated.keys(): #print "YO " + str(generated[entity]) #dot.add_edge(pydot.Edge(generated[entity]["prov:activity"], generated[entity]["prov:entity"], label = "GENERATED: " + generated[entity]["prov:label"])) dot.add_edge(pydot.Edge(generated[entity]["prov:entity"], generated[entity]["prov:activity"], label = "GENERATED: " + generated[entity]["prov:label"])) #graph.add_edge(Generated(graph.node_named(generated[entity]["prov:activity"]), graph.node_named(generated[entity]["prov:entity"]), generated[entity])) graph.add_edge(Generated(graph.node_named(generated[entity]["prov:entity"]), graph.node_named(generated[entity]["prov:activity"]), generated[entity]))
# human labels are the majority labels for things hl = human_labels hl = [s.replace(':', '-') for s in hl] hl = [s.replace('null', 'no-observation') for s in hl] print(hl) for i in num_labels: new_node = Node(str(hl[i])) col = colors_viridis(i) col = matplotlib.colors.rgb2hex(col) # print(matplotlib.colors.rgb2hex(col)) new_node.set_color(col) g.add_node(new_node) print("Add node " + str(hl[i])) for i_a in num_labels: best = sorted(zip(transmats[i_a], hl), reverse=True)[:3] for j_b in num_labels: a = hl[i_a] b = hl[j_b] edge = pydot.Edge(str(a), str(b)) # edge.set_color('black') print("edge from " + a + " to " + b) prob_label = transmats[i_a][j_b] if (prob_label,b) in best: # print("found a best")
ref_edges.add((pdEdges['source'][i], pdEdges['target'][i])) if (pdEdges['source'][i], pdEdges['target'][i]) not in Edges: Edges[(pdEdges['source'][i], pdEdges['target'][i])] = 0 Edges[(pdEdges['source'][i], pdEdges['target'][i])] += 1 for edge in Edges: GeneGraph[edge[0]]['adj'].append((edge[1], Edges[edge])) G = Dot() for node in GeneGraph: if node in ref_nodes: G.add_node(Node(name=node, width=str(GeneGraph[node]['length']), color='red')) else: G.add_node(Node(name=node, width=str(GeneGraph[node]['length']), color='blue')) for node in GeneGraph: for _node in GeneGraph[node]['adj']: if (node, _node[0]) in ref_edges: G.add_edge(Edge(src=node, dst=_node[0], penwidth=str(np.sqrt(_node[1])), weight=str(_node[1]), color='red')) else: G.add_edge(Edge(src=node, dst=_node[0], penwidth=str(np.sqrt(_node[1])), weight=str(_node[1]), color='blue')) for i in G.get_nodes(): i.set_shape('box') i.set_style('filled')
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)
# create a new graph and add the nodes to it graph = Dot() for name in names: # the label of the node if name_to_newlabel[name] != "": label = str(name_to_newlabel[name]) + "\n" + name_to_software[name] else: label = name_to_software[name] graph.add_node( Node(name, fillcolor=name_to_color[name], color=name_to_color[name], style="filled", fontname="cantarell bold", fontcolor="#ffffff", fontsize=22, label=label)) # get all the edges connected two processes edges = set() for name, paths in name_to_paths.items(): for path in paths: for descendant in path: if (descendant in names) and (descendant != name): edges.add((name, descendant)) break # add the edges to the graph
def create_graph(self, image_format, image_path): from pydot import Dot, Edge, Node graph = Dot(graph_type='digraph') graph_nodes = {} graph_edges = {} done = set() def add_node(node, expanded=False, chosen=False, in_fringe=False, in_successors=False, solution=False): node_id = id(node) if node_id not in graph_nodes: label = node.state_representation() if hasattr(node, 'cost'): label += '\nCost: %s' % node.cost if hasattr(node, 'heuristic'): label += '\nHeuristic: %s' % node.heuristic if hasattr(node, 'value'): label += '\nValue: %s' % node.value new_g_node = Node(node_id, label=label, style='filled', shape='circle', fillcolor='#ffffff', fontsize=self.font_size) graph_nodes[node_id] = new_g_node g_node = graph_nodes[node_id] if expanded or chosen: g_node.set_fillcolor(self.fringe_color) if in_fringe: g_node.set_color(self.fringe_color) g_node.set_penwidth(3) if in_successors: g_node.set_color(self.successor_color) g_node.set_fontcolor(self.successor_color) if solution: g_node.set_fillcolor(self.solution_color) return g_node 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 if self.last_event.name == 'chosen_node': add_node(self.last_chosen, chosen=True) if self.last_event.name == 'finished': if self.solution_node: add_node(self.solution_node, solution=True) if self.last_event.name == 'expanded': for node, successors in zip(self.last_expandeds, self.last_successors): add_node(node, expanded=True) for successor_node in successors: add_edge_to_parent(successor_node, is_successor=True, parent=node) for node in self.current_fringe: add_node(node, in_fringe=True) while node is not None and node not in done: if node.parent is not None: add_edge_to_parent(node) else: add_node(node) done.add(node) node = node.parent for node_id in sorted(graph_nodes.keys()): graph.add_node(graph_nodes[node_id]) for node_id, parent_id in sorted(graph_edges.keys()): graph.add_edge(graph_edges[node_id, parent_id]) graph.write(image_path, format=image_format)
class Grafo: def __init__(self, vertices, use_pydot=False): self.__verts__ = vertices self.__adjmx__ = [[] for i in range(vertices)] self.__arest__ = 0 if use_pydot: self.__graph__ = Dot(graph_type='graph') for i in range(vertices): self.__graph__.add_node(Node(str(i))) else: self.__graph__ = None 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 aresta_aleat(self): done = False while not done: v1 = __random_gen__.randint(self.__verts__) v2 = v1 while v2 == v1: v2 = __random_gen__.randint(self.__verts__) done = self.aresta(v1, v2) def conecta(self, alfa): max_art = (self.__verts__ * (self.__verts__ - 1)) // 2 arestas = round(alfa * max_art) for _ in range(arestas): self.aresta_aleat() def show(self): if self.__graph__ is not None: from IPython.display import Image return Image(self.__graph__.create(format='png')) def contemC4(self): for v in range(self.__verts__): tem_caminho = [False] * self.__verts__ for w in self.__adjmx__[v]: for u in self.__adjmx__[w]: if u != v: if tem_caminho[u]: return v else: tem_caminho[u] = True return -1 def testeC4(self, vert): def mostra_C4(v): if self.__graph__ is not None: for i in range(len(v)): self.__graph__.get_node(str(v[i]))[0].set_style('filled') self.__graph__.get_edge(str(v[i]), str( v[(i + 1) % len(v)]))[0].set_style('bold') for v in self.__adjmx__[vert]: for w in self.__adjmx__[v]: if w != vert: for u in self.__adjmx__[w]: if u != vert and u != v: for z in self.__adjmx__[u]: if z == vert: mostra_C4([vert, v, w, u]) return True return False
def save_automaton_to_file(automaton, path="LearnedModel", file_type='dot', display_same_state_trans=True, visualize=False, round_floats=None): """ The Standard of the automata strictly follows the syntax found at: https://automata.cs.ru.nl/Syntax/Overview. For non-deterministic and stochastic systems syntax can be found on AALpy's Wiki. Args: automaton: automaton to be saved to file path: file in which automaton will be saved (Default value = "LearnedModel") file_type: Can be ['dot', 'png', 'svg', 'pdf'] (Default value = 'dot') display_same_state_trans: True, should not be set to false except from the visualization method (Default value = True) visualize: visualize the automaton round_floats: for stochastic automata, round the floating point numbers to defined number of decimal places Returns: """ assert file_type in file_types if file_type == 'dot' and not display_same_state_trans: print("When saving to file all transitions will be saved") display_same_state_trans = True automaton_type = automaton_types[automaton.__class__] graph = Dot(path, graph_type='digraph') for state in automaton.states: graph.add_node(_get_node(state, automaton_type)) for state in automaton.states: _add_transition_to_graph(graph, state, automaton_type, display_same_state_trans, round_floats) # add initial node graph.add_node(Node('__start0', shape='none', label='')) graph.add_edge(Edge('__start0', automaton.initial_state.state_id, label='')) if file_type == 'string': return graph.to_string() else: try: graph.write(path=f'{path}.{file_type}', format=file_type if file_type != 'dot' else 'raw') print(f'Model saved to {path}.{file_type}.') if visualize and file_type in {'pdf', 'png', 'svg'}: try: import webbrowser abs_path = os.path.abspath(f'{path}.{file_type}') path = f'file:///{abs_path}' webbrowser.open(path) except OSError: traceback.print_exc() print(f'Could not open the file {path}.{file_type}.', file=sys.stderr) except OSError: traceback.print_exc() print(f'Could not write to the file {path}.{file_type}.', file=sys.stderr)
def save_ex(self, filename, format='dot'): """Save basic block graph into a file. """ fontname = 'Ubuntu Mono' # fontname = 'DejaVu Sans Mono' # fontname = 'DejaVu Sans Condensed' # fontname = 'DejaVu Sans Light' # fontname = 'Liberation Mono' # fontname = 'DejaVu Serif Condensed' # fontname = 'Ubuntu Condensed' node_format = { 'shape': 'plaintext', 'rankdir': 'LR', 'fontname': fontname, 'fontsize': 9.0, 'penwidth': 0.5, # 'style' : 'filled', # 'fillcolor' : 'orange', } edge_format = { 'fontname': fontname, 'fontsize': 8.0, 'penwidth': 0.5, 'arrowsize': 0.6, 'arrowhead': 'vee', } edge_colors = { 'direct': 'blue', 'indirect': 'red', } label_fmt = '<' label_fmt += '<table border="1.0" cellborder="0" cellspacing="1" cellpadding="0" valign="middle">' label_fmt += ' <tr><td align="center" cellpadding="1" port="enter"></td></tr>' label_fmt += ' <tr><td align="left" cellspacing="1">{label}</td></tr>' label_fmt += ' <tr><td align="center" cellpadding="1" port="exit" ></td></tr>' label_fmt += '</table>' label_fmt += '>' try: dot_graph = Dot(graph_type="digraph", rankdir="TB", splines="ortho", nodesep=1.2) # add nodes nodes = {} for cfg_addr in self._graph.node.keys(): if cfg_addr != "unknown": if cfg_addr in self._cfg_by_addr and not isinstance( self._cfg_by_addr[cfg_addr], str) and self._cfg_by_addr[cfg_addr].name: cfg_label = self._cfg_by_addr[cfg_addr].name else: cfg_label = "sub_{:x}".format(cfg_addr) else: cfg_label = "unknown" label = label_fmt.format(label=cfg_label) nodes[cfg_addr] = Node(cfg_addr, label=label, **node_format) dot_graph.add_node(nodes[cfg_addr]) # add edges for cfg_src_addr in self._graph.node.keys(): for cfg_dst_addr in self._edges.get(cfg_src_addr, []): if cfg_dst_addr == "unknown": branch_type = "indirect" else: branch_type = "direct" dot_graph.add_edge( Edge(nodes[cfg_src_addr], nodes[cfg_dst_addr], color=edge_colors[branch_type], **edge_format)) dot_graph.write("{}.{}".format(filename, format), format=format) except Exception as err: logger.error("Failed to save basic block graph: %s (%s)", filename, format, exc_info=True)
def plot_cfg(cfg, fname, format="png", path=None, asminst=False, vexinst=False, func_addr=None, remove_imports=True, remove_path_terminator=True, debug_info=False): dot_graph = Dot(graph_type="digraph", rankdir="TB") nodes = {} blocks = {} nmap = {} nidx = 0 ccfg_graph = networkx.DiGraph(cfg.graph) filtered_addr = set() if func_addr != None: for node in ccfg_graph.nodes(): if node.function_address not in func_addr: ccfg_graph.remove_node(node) filtered_addr.add(node.addr) else: if remove_imports: eaddrs = import_addrs(cfg.project) for node in ccfg_graph.nodes(): if node == None: continue if node.addr in eaddrs: try: ccfg_graph.remove_node(node) filtered_addr.add(node.addr) except: pass for pnode in node.predecessors: try: ccfg_graph.remove_node(pnode) filtered_addr.add(node.addr) except: pass if remove_path_terminator: for node in ccfg_graph.nodes(): if hasattr(node, 'is_simprocedure') and hasattr( node, 'simprocedure_name' ) and node.is_simprocedure and node.simprocedure_name == "PathTerminator": ccfg_graph.remove_node(node) filtered_addr.add(node.addr) node_path = [] if path != None: trace = list(filter(lambda _: _ not in filtered_addr, path.addr_trace)) for i in range(len(trace)): nodes_at_addr = cfg.get_all_nodes(trace[i]) if len(nodes_at_addr) == 1: node_path.append(nodes_at_addr[0]) else: for n in nodes_at_addr: if node_matches(n, trace[:i + 1]): node_path.append(n) break active_nodes = set(node_path) active_edges = {} if len(node_path) > 0: for s, t in zip(node_path[:-1], node_path[1:]): if s not in active_edges: active_edges[s] = set() active_edges[s].add(t) for node in sorted(filter(lambda _: _ != None, ccfg_graph.nodes()), key=lambda _: _.addr): attributes = [] if node.is_simprocedure: attributes.append("SIMP") if node.is_syscall: attributes.append("SYSC") if node.no_ret: attributes.append("NORET") if len(attributes) == 0: blocks[node.addr] = cfg.project.factory.block(addr=node.addr, max_size=node.size) else: blocks[node.addr] = cfg.project.factory.block(addr=node.addr) nmap[node] = nidx nidx += 1 label = "{{<f0> {:#08x} ({:#08x}) {} {}".format( node.addr, node.function_address, node.name, ' '.join(attributes)) if not node.is_simprocedure: if asminst: label += "| " + print_asm(blocks[node.addr]) if vexinst: label += "| " + print_vex(blocks[node.addr]) if debug_info: label += "| " + node_debug_info(node) label += "}}" penwidth = '1' if node in active_nodes: penwidth = '3' if not node.is_simprocedure: nodes[nmap[node]] = Node(nmap[node], label=label, penwidth=penwidth, **default_node_attributes) else: if node.simprocedure_name == "PathTerminator": nodes[nmap[node]] = Node(nmap[node], label=label, penwidth=penwidth, style="filled", fillcolor="#dd5555", **default_node_attributes) else: nodes[nmap[node]] = Node(nmap[node], label=label, penwidth=penwidth, style="filled", fillcolor="#dddddd", **default_node_attributes) dot_graph.add_node(nodes[nmap[node]]) #for n in ccfg.graph.nodes(): # nn = filter(lambda node: node in nmap, cfg.get_all_nodes(n.addr)) # if len(nn)>1: # for n in nn[1:]: # dot_graph.add_edge(Edge(nodes[nmap[nn[0]]],nodes[nmap[n]],style="invis")) edgeprop = {} for source, target in ccfg_graph.edges(): if source == None or target == None: continue key = (nmap[source], nmap[target]) edge_style = 'solid' if not key in edgeprop: if blocks[source.addr].vex.jumpkind == 'Ijk_Boring': if len(blocks[source.addr].vex.constant_jump_targets) > 1: if len(blocks[source.addr].vex.next.constants) == 1: if target.addr == blocks[ source.addr].vex.next.constants[0].value: color = EDGECOLOR_CONDITIONAL_FALSE else: color = EDGECOLOR_CONDITIONAL_TRUE else: color = EDGECOLOR_UNKNOWN else: color = EDGECOLOR_UNCONDITIONAL elif blocks[source.addr].vex.jumpkind == 'Ijk_Call': color = EDGECOLOR_CALL if len(blocks[source.addr].vex.next.constants) == 1 and blocks[ source. addr].vex.next.constants[0].value != target.addr: edge_style = 'dotted' elif blocks[source.addr].vex.jumpkind == 'Ijk_Ret': color = EDGECOLOR_RET else: color = EDGECOLOR_UNKNOWN penwidth = '1' if source in active_edges and target in active_edges[source]: penwidth = '3' edgeprop[key] = { "color": color, "penwidth": penwidth, } dot_graph.add_edge( Edge(nodes[nmap[source]], nodes[nmap[target]], color=edgeprop[key]["color"], style=edge_style, penwidth=edgeprop[key]["penwidth"], **default_edge_attributes)) dot_graph.write("{}.{}".format(fname, format), format=format)