Python Dot.add_edge方法代码示例

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
def graphFromList(edge_list, node_prefix='', directed=True):
    """Creates a basic graph out of an edge list.
    
    The edge list has to be a list of tuples representing
    the nodes connected by the edge.
    The values can be anything: bool, int, float, str.
    
    If the graph is undirected by default, it is only
    calculated from one of the symmetric halves of the matrix.

    If the graph has weighted edges, edge_list will be of the 
    form:
        [ (vert1, vert2, weight), ... ]
    else:
        [ (vert1, vert2), ... ]
    
    """
    weighted = len(edge_list[0]) % 2
    if directed:
            graph = Dot(graph_type='digraph')
    else:
            graph = Dot(graph_type='graph')
    for edge in edge_list:
            e = Edge(node_prefix+str(edge[0]), node_prefix+str(edge[1]))
            if weighted:
                e.label = e.weight = edge[2]
            graph.add_edge(e)
    return graph

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
    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()

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
 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'))

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
    def write(self, filename, format="png", append_ext=False, prog="dot"):
        "Builds a pydot graph and writes to file"
        from pydot import Dot, Edge, Node

        dot = Dot(graph_type='digraph', **self.graph_attributes)
        if format not in dot.formats:
            raise GraphException("invalid format '%s'" % format)
        node_cache = {}

        def get_node(s):
            try:
                return node_cache[s]
            except KeyError:
                node = Node(s, **self.node_attributes.get(s, {}))
                dot.add_node(node)
                node_cache[s] = node
                return node

        for (s0, s1), attr in self.edge_attributes.iteritems():
            dot.add_edge(Edge(get_node(s0), get_node(s1),
                            **self.edge_attributes.get((s0, s1), {})))

        for node in self.get_orphaned_nodes():
            get_node(node)

        if append_ext:
            filename = "%s.%s" % (filename, format)
        dot.write(filename, format=format, prog=prog)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
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

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
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

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
    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)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
    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())

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
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 

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
    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 ""

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
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)

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
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

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
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

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
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

# 需要导入模块: from pydot import Dot [as 别名]
# 或者: from pydot.Dot import add_edge [as 别名]
    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')