Example #1
0
    def draw(self, name, dname, draw_branches=True):
        """
        Writes the current graph as a PNG file

        :param str name: filename (without .png)
        :param str dname: directory of the output png
        :param draw_branches:
        :return:
        """
        from pydot import Dot, Edge
        import os

        g = Dot()
        g.set_node_defaults(color='lightgray',
                            style='filled',
                            shape='box',
                            fontname='Courier',
                            fontsize='10')
        for node in sorted(self.nodes, key=lambda x: x.num):
            if draw_branches and node.type.is_cond:
                g.add_edge(Edge(str(node), str(node.true), color='green'))
                g.add_edge(Edge(str(node), str(node.false), color='red'))
            else:
                for suc in self.sucs(node):
                    g.add_edge(Edge(str(node), str(suc), color='blue'))
            for except_node in self.catch_edges.get(node, []):
                g.add_edge(Edge(str(node),
                                str(except_node),
                                color='black',
                                style='dashed'))

        g.write(os.path.join(dname, '%s.png' % name), format='png')
Example #2
0
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')
Example #3
0
 def __init__(self, nome, custo, vertice1, vertice2):
     self.__nome = nome
     self.__custo = custo
     self.__vertice1 = vertice1
     self.__vertice2 = vertice2
     self.__aresta = Edge(str(vertice1.getNome()), str(vertice2.getNome()))
     self.__aresta.set_label(custo)
     self.__aresta.set_labelfontcolor("#009933")
     self.__aresta.set_fontsize(10.0)
     self.__aresta.set_color("#38516b")
Example #4
0
 def add_edge(self,*args,**kwargs):
     if len(args)==1 and isinstance(args[0],Edge):
         edge = args[0]
     else:
         edge = Edge(*args,**kwargs)
     #end if
     src = edge.get_source()
     dst = edge.get_destination()
     self.edges[src,dst] = edge
     self.graph.add_edge(edge)
Example #5
0
 def add_edge(self,*args,**kwargs):
     if len(args)==1 and isinstance(args[0],Edge):
         edge = args[0]
     else:
         edge = Edge(*args,**kwargs)
     #end if
     src = edge.get_source()
     dst = edge.get_destination()
     self.edges[src,dst] = edge
     self.graph.add_edge(edge)
Example #6
0
    def graph(self, model_classes):
        graph = Dot(**self.graph_options)
        relations = set()

        # Create nodes from mappers
        mappers = list(map(class_mapper, model_classes))
        for mapper in mappers:
            graph.add_node(
                Node(
                    self.quote(mapper),
                    label=self.node_table(
                        mapper.class_.__name__,
                        self._model_columns(mapper),
                        self._model_operations(mapper),
                    ),
                    **self.style["node"],
                )
            )
            if mapper.inherits:
                graph.add_edge(
                    Edge(
                        *map(self.quote, (mapper.inherits, mapper)),
                        **self.style["inheritance"],
                    )
                )
            for loader in mapper.iterate_properties:
                if (
                    isinstance(loader, RelationshipProperty)
                    and loader.mapper in mappers
                ):
                    reverse = getattr(loader, "_reverse_property")
                    if len(reverse) == 1:
                        relations.add(frozenset((loader, next(iter(reverse)))))
                    else:
                        relations.add((loader,))

        # Create edges from relationships between mappers
        for relation in relations:
            options = self.style["relationship"].copy()
            if len(relation) == 2:
                src, dest = relation
                if src.viewonly and dest.viewonly:
                    options.update(self.style["relationship-viewonly"])
                between = src.parent, dest.parent
                options["headlabel"] = self._format_relationship(src)
                options["taillabel"] = self._format_relationship(dest)
                options["dir"] = "both"
            else:
                (prop,) = relation
                between = prop.parent, prop.mapper
                options["headlabel"] = self._format_relationship(prop)
                if prop.viewonly:
                    options.update(self.style["relationship-viewonly"])
            graph.add_edge(Edge(*map(self.quote, between), **options))
        return graph
Example #7
0
 def mk_merge_edge(graph, src_node, tgt_node, kind, label, important):
     """Add a merge edge to the graph"""
     if important:
         color = "red"
     else:
         color = "grey"
     e = Edge(
         src_node, tgt_node, constraint="false", label='"' + label + '"', color=color, fontcolor=color, style="bold"
     )
     if kind.startswith("cherry"):
         e.set_style("dashed")
     graph.add_edge(e)
Example #8
0
    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
Example #9
0
 def draw(self, name, dname, draw_branches=True):
     from pydot import Dot, Edge
     g = Dot()
     g.set_node_defaults(color='lightgray', style='filled', shape='box',
                         fontname='Courier', fontsize='10')
     for node in sorted(self.nodes, key=lambda x: x.num):
         if draw_branches and node.type.is_cond:
             g.add_edge(Edge(str(node), str(node.true), color='green'))
             g.add_edge(Edge(str(node), str(node.false), color='red'))
         else:
             for suc in self.sucs(node):
                 g.add_edge(Edge(str(node), str(suc), color='blue'))
     g.write_png('%s/%s.png' % (dname, name))
Example #10
0
 def mk_merge_edge(graph, src_node, tgt_node, kind, label, important):
   """Add a merge edge to the graph"""
   if important:
     color = 'red'
   else:
     color = 'grey'
   e = Edge(src_node, tgt_node, constraint='false',
            label='"' + label + '"',
            color=color, fontcolor=color,
            style='bold')
   if kind.startswith('cherry'):
     e.set_style('dashed')
   graph.add_edge(e)
Example #11
0
    def _print_tree(self, graph):
        root = self.get_node_str()
        if self.is_leaf:
            return graph
        left_tree_str = self.left_tree.get_node_str()
        right_tree_str = self.right_tree.get_node_str()
        # print('left', left_tree_str)
        # print('right', right_tree_str)

        graph.add_edge(Edge(src=root, dst=left_tree_str))
        graph = self.left_tree._print_tree(graph)
        graph.add_edge(Edge(src=root, dst=right_tree_str))
        graph = self.right_tree._print_tree(graph)
        return graph
Example #12
0
    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
Example #13
0
class Aresta():
    def __init__(self, nome, custo, vertice1, vertice2):
        self.__nome = nome
        self.__custo = custo
        self.__vertice1 = vertice1
        self.__vertice2 = vertice2
        self.__aresta = Edge(str(vertice1.getNome()), str(vertice2.getNome()))
        self.__aresta.set_label(custo)
        self.__aresta.set_labelfontcolor("#009933")
        self.__aresta.set_fontsize(10.0)
        self.__aresta.set_color("#38516b")

    def setNome(self, nome):
        self.__nome = nome

    def setCusto(self, custo):
        self.__custo = custo

    def getNome(self):
        return self.__nome

    def getCusto(self):
        return self.__custo

    def getVertice1(self):
        return self.__vertice1

    def getVertice2(self):
        return self.__vertice2

    def getVertices(self):
        return [self.__vertice1, self.__vertice2]

    def getAresta(self):
        return self.__aresta
Example #14
0
    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
Example #15
0
    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
Example #16
0
    def __init__(self, src, dst, attr):
        obj_dict = dict()
        obj_dict[ 'attributes' ] = attr
        obj_dict[ 'type' ] = 'edge'
        obj_dict[ 'parent_graph' ] = None
        obj_dict[ 'parent_edge_list' ] = None
        obj_dict[ 'sequence' ] = None
        if isinstance(src, Node):
            src = src.get_name()
        if isinstance(dst, Node):
            dst = dst.get_name()
        points = ( quote_if_necessary( src) , quote_if_necessary( dst) )
        obj_dict['points'] = points

        Edge.__init__(self, src, dst, obj_dict)
Example #17
0
    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)
Example #18
0
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')
Example #19
0
 def mk_merge_edge(graph, src_node, tgt_node, kind, label, important):
     """Add a merge edge to the graph"""
     if important:
         color = 'red'
     else:
         color = 'grey'
     e = Edge(src_node,
              tgt_node,
              constraint='false',
              label='"' + label + '"',
              color=color,
              fontcolor=color,
              style='bold')
     if kind.startswith('cherry'):
         e.set_style('dashed')
     graph.add_edge(e)
Example #20
0
    def show_diagram(self, path=None):
        """
            Creates the graph associated with this DFA
        """
        # Nodes are set of states

        graph = Dot(graph_type='digraph', rankdir='LR')
        nodes = {}
        for state in self.states:
            if state == self.initial_state:
                # color start state with green
                initial_state_node = Node(
                    state, style="filled", fillcolor="green")
                nodes[state] = initial_state_node
                graph.add_node(initial_state_node)
            else:
                state_node = Node(state)
                nodes[state] = state_node
                graph.add_node(state_node)
        # adding edges
        for from_state, lookup in self.transitions.items():
            for to_label, to_state in lookup.items():
                graph.add_edge(Edge(
                    nodes[from_state],
                    nodes[to_state],
                    label=to_label
                ))
        if path:
            graph.write_png(path)
        return graph
Example #21
0
    def visualize(self, filename):
        """Save a graphical representation of this AF."""
        graph = Dot(graph_type='digraph')

        for arg in self.args:
            text = arg.text

            # Add any offers to the text that this argument may support
            for off, supp in self.supp_args.items():
                if arg in supp:
                    text += f"\n[{off}]"

            graph.add_node(Node(name=text))

        for att in self.attacks:
            texts = []

            for arg in [att.arg_start, att.arg_end]:
                texts.append(arg.text)

                for off, supp in self.supp_args.items():
                    if arg in supp:
                        texts[-1] += f"\n[{off}]"
            if att.arg_start not in self.args or \
                    att.arg_end not in self.args:
                print(f"Warning: attack in AF but not its start or end")

            graph.add_edge(Edge(texts[0], texts[1], dirType="forward"))

        graph.write_png(filename)
def add_edge(graph,
             tail_node,
             head_node,
             label="[0%]",
             style="solid, bold",
             color="black",
             constraint="true"):
    """
       Add an edge to a graph or subgraph
       
       :param graph: graph or subgraph to which the edge is added
       :param tail_node: origin of the edge
       :param head_node: destination of the edge
       :param label: the label
       :param style: the style
       :param color: the color
       :param constraint: the constraint
    """
    edge = Edge(tail_node,
                head_node,
                label=label,
                style=style,
                color=color,
                constraint="true")
    graph.add_edge(edge)
    return
Example #23
0
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
Example #24
0
    def add_annotation(graph, node, label, color='lightblue'):
        """Add a graph node that serves as an annotation to a normal node.
       More than one annotation can be added to the same normal node."""
        subg_name = node + '_annotations'

        def get_subgraph(graph, name):
            """Equivalent to pydot.Graph.get_subgraph() when there is no more than
         one subgraph of the given name, but working aroung a bug in
         pydot.Graph.get_subgraph()."""
            for subg in graph.get_subgraph_list():
                if subg.get_name() == name:
                    return subg
            return None

        g = get_subgraph(graph, subg_name)
        if not g:
            g = pydot.Subgraph(subg_name, rank='same')
            graph.add_subgraph(g)

        ann_node = node + '_'
        while g.get_node(ann_node):
            ann_node = ann_node + '_'
        g.add_node(
            Node(ann_node,
                 shape='box',
                 style='filled',
                 color=color,
                 label='"' + label + '"'))
        g.add_edge(
            Edge(ann_node,
                 node,
                 style='solid',
                 color=color,
                 dir='none',
                 constraint='false'))
Example #25
0
    def _create_edge(self, nodes, cfg_src_addr, cfg_dst_addr):
        if cfg_dst_addr == "unknown":
            branch_type = "indirect"
        else:
            branch_type = "direct"

        return Edge(nodes[cfg_src_addr], nodes[cfg_dst_addr], color=self.edge_color[branch_type], **self.edge_format)
Example #26
0
def visualize_fpta(red):
    red_sorted = sorted(list(red), key=lambda x: len(x.prefix))
    graph = Dot('fpta', graph_type='digraph')

    for i, r in enumerate(red_sorted):
        r.state_id = f'q{i}'
        graph.add_node(Node(r.state_id, label=r.state_id))

    for r in red_sorted:
        for i, c in r.children.items():
            graph.add_edge(Edge(r.state_id, c.state_id, label=i))

    graph.add_node(Node('__start0', shape='none', label=''))
    graph.add_edge(Edge('__start0', red_sorted[0].state_id, label=''))

    return graph
Example #27
0
    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
Example #28
0
    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
Example #29
0
 def start_graph(g, node, parent_node_name=None):
     g.add_node(
         Node(name=node.getNodeNum(),
              shape='plaintext',
              label=node.getLabel()))
     if parent_node_name:
         g.add_edge(Edge(parent_node_name, node.getNodeNum()))
     if len(node.getKids()) > 0:
         for kid in node.getKids():
             start_graph(g, kid, node.getNodeNum())
     else:
         g.add_node(
             Node(name=f'{node.getNodeNum()}_content',
                  shape='plaintext',
                  label=node.getContent()))
         g.add_edge(
             Edge(node.getNodeNum(), f'{node.getNodeNum()}_content'))
Example #30
0
        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
Example #31
0
    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
Example #32
0
    def draw_missing_child(self, context: DrawContext, parent: Node) -> None:
        """Adds an empty node and edge for nodes with a single child.

        This avoids quirky behavior from drawing additional edges in graphs
        where the extra edge would run past nodes with only a single child.
        """
        target = f":d{id(parent)}"
        context.graph.add_node(DotNode(target, **self.hidden_node))
        context.graph.add_edge(Edge(str(id(parent)), target, style="invis"))
Example #33
0
def get_nodes_and_edges(name='my_graph'):
    graph = Graph(cleanup(name))
    edges = []
    for orm_node in Node.objects.select_related():
        graph.add_node(get_node(orm_node.name))
        for parent in orm_node.parent.iterator():
            edges.append((cleanup(parent.parent.name),cleanup(parent.child.name)))

        for child in orm_node.child.iterator():
            edges.append((cleanup(child.parent.name),cleanup(child.child.name)))            

    edges = list(set(edges)) # remove duplicates   
    for edge in edges:
        e = Edge(edge[0],edge[1])
        e.set_target('_parent')        
        e.set_arrowhead('vee')
        graph.add_edge(e)            
    return graph
Example #34
0
 def mk_edge(graph, name1, name2, **attrs):
     """Add an ordinary edge to the graph"""
     graph.add_edge(
         Edge(name1,
              name2,
              dir='none',
              style='dotted',
              color='grey',
              **attrs))
Example #35
0
 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
Example #36
0
    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())
Example #37
0
def generate_links(graph, state_obj, nodes, nodemap):
    rules = {
        'require': {'color': '#0000ff'},
        'require_in': {'color': '#9090ff', 'reverse': True, 'style': 'dashed', },
        'watch': {'color': '#ff0000'},
        'watch_in': {'color': '#ff9090', 'reverse': True, 'style': 'dashed', },
    }
    seen = set()
    for state in state_obj:
        node_name = '{0}.{1}'.format(state.get('state'), state.get('__id__'))
        if node_name in seen:
            continue
        seen.add(node_name)
        for edge_type, ruleset in rules.items():
            for target in targets_name(state.get(edge_type), nodes, nodemap):
                src, dst = node_name, target
                if ruleset.get('reverse'):
                    src, dst = dst, src
                edge = Edge(dst, src, color=ruleset['color'])
                if 'style' in ruleset:
                    edge.set_style(ruleset.get('style'))
                graph.add_edge(edge)
Example #38
0
def get_node_and_edges(name):
    graph = Graph(cleanup(name))
    orm_node = Node.objects.select_related().get(name=name)    
    other_nodes = [x for x in orm_node.parent.iterator()]
    other_nodes += [x for x in orm_node.child.iterator()]
    edges = []
    node_check = [] # used to make sure we don't add the same node twice
    for other_node in other_nodes:
        if other_node.parent.name not in node_check:
            graph.add_node(get_node(other_node.parent.name))
            node_check.append(other_node.parent.name)
        if other_node.child.name not in node_check:
            graph.add_node(get_node(other_node.child.name))        
            node_check.append(other_node.child.name)

        # edges are tuples
        edges.append((cleanup(other_node.parent.name),cleanup(other_node.child.name))) 

    edges = list(set(edges)) # remove duplicates
    for edge in edges:
        e = Edge(edge[0],edge[1])
        e.set_arrowhead('vee')
        graph.add_edge(e)
    return graph
from pyd.atm_state import *
from pydot import Dot, Node, Edge


file = "/tmp/atm_state_machine.png"

dot = Dot(graph_type="digraph", comment="Atm State Machine")
nodes = {}
graph = {}
for name, state in State.get_subclasses_dict().iteritems():
    nodes.setdefault(name, Node(name))

for name, state in State.get_subclasses_dict().iteritems():
    for event, state in state.get_valid_events():
        edge = Edge(nodes.get(name), nodes.get(state))
        edge.set_label(event)
        graph.setdefault(name, []).append(edge)

for name, edges in graph.iteritems():
    for edge in edges:
        dot.add_node(nodes.get(name))
        dot.add_edge(edge)

dot.write_png(file)