Python pygraphviz.AGraph类代码示例

 def run_graph(dot):
     """ Runs graphviz to see if the syntax is good. """
     graph = AGraph()
     graph = graph.from_string(dot)
     extension = 'png'
     graph.draw(path='output.png', prog='dot', format=extension)
     sys.exit(0)

def build_graph(ts):
    g = AGraph(directed=True)
    g.add_edges_from(ts.ts.todok().keys())
    g.graph_attr['overlap'] = 'scalexy'
    for n, s in zip(g.nodes(), ts._pwa.states):
        n.attr['label'] = s
    return g

    def get_graphviz(self, triple_args_function=None,
                     ignore_properties=VIS_IGNORE_PROPERTIES):
        """
        Create a pygraphviz graph from the tree
        """
        def _id(node):
            return node.uri.split("/")[-1]
        g = AGraph(directed=True)
        triples = list(self.get_triples())
        nodeset = set(chain.from_iterable((t.subject, t.object)
                                          for t in triples))
        for n in nodeset:
            label = "%s: %s" % (n.id, n.word)
            for k, v in n.__dict__.iteritems():
                if k not in ignore_properties:
                    label += "\\n%s: %s" % (k, v)
            g.add_node(_id(n), label=label)

        # create edges
        for triple in triples:
            kargs = (triple_args_function(triple)
                     if triple_args_function else {})
            if 'label' not in kargs:
                kargs['label'] = triple.predicate
            g.add_edge(_id(triple.subject), _id(triple.object), **kargs)
        # some theme options
        g.graph_attr["rankdir"] = "BT"
        g.node_attr["shape"] = "rect"
        g.edge_attr["edgesize"] = 10
        g.node_attr["fontsize"] = 10
        g.edge_attr["fontsize"] = 10

        return g

def graphviz_to_firebase(dirname,filename):
    """
    since several chars must be escaped from firebase keys,
    (see #http://stackoverflow.com/questions/19132867/adding-firebase-data-dots-and-forward-slashes
    we can't directly use them as keys so:
    - we use integer i as key,
    - "nodes" dict maps node name to i to preserve edges coherency
    - node name is kept as default node label
    """
    f=os.path.join(dirname, filename)
    graph=filename.split('.')[0]
    print('processing %s'%f),
    agraph=AGraph(f)
    nodes={}
    for i,node in enumerate(agraph.iternodes()):
        nodes[node]=i
        attrs={}
        attrs.update(agraph.node_attr)
        attrs['label']=node #default label is node id
        attrs.update(node.attr)
        key='%s/node/%d'%(graph,i)
        ref.patch(key,attrs)
        print('.'),
    for i,edge in enumerate(agraph.iteredges()):
        attrs={}
        attrs.update(agraph.edge_attr)
        attrs.update(edge.attr)
        attrs['source']=nodes[edge[0]]
        attrs['target']=nodes[edge[1]]
        #edges are added as attributes of their destination node
        key='%s/edge/%d'%(graph,i)
        ref.patch(key,attrs)
        print('-'),
    logging.info('ok')

    def render(self, filename):
        g = AGraph(strict=False, directed=True)

        # create nodes
        for frame_id, node in self.callers.items():
            label = "{ %s }" % node
            g.add_node(frame_id, shape='Mrecord', label=label,
                       fontsize=13, labelfontsize=13)

        # create edges
        for frame_id, node in self.callers.items():
            child_nodes = []
            for child_id in node.child_methods:
                child_nodes.append(child_id)
                g.add_edge(frame_id, child_id)

            # order edges l to r
            if len(child_nodes) > 1:
                sg = g.add_subgraph(child_nodes, rank='same')
                sg.graph_attr['rank'] = 'same'
                prev_node = None
                for child_node in child_nodes:
                    if prev_node:
                        sg.add_edge(prev_node, child_node, color="#ffffff")
                    prev_node = child_node

        g.layout()
        g.draw(path=filename, prog='dot')

        print("callviz: rendered to %s" % filename)
        self.clear()

 def draw(self):
     tree = self.to_tree()
     A = AGraph(tree)
     if not self.filename:
         self.filename = input('Please input a filename:')
     A.draw('temp/{}.jpg'.format(self.filename),
            format='jpg', prog='fdp')

def path_graph(nodes):
    graph = AGraph(directed=True)

    for node in nodes:
        graph.add_node(node, shape='rectangle')

    graph.add_path(nodes)
    return graph

    def processLines(self):
        if len(self.lines) == 0:
            return
        
        self.identifier = self.lines[0][2:]

        s = '\n'.join(self.lines)
        A = AGraph()
        G = A.from_string(s)
        self.processGraph(G)

def dot_to_graph(dot, output_path):
    """
    Render by calling graphviz the figure on the output path.
    :param dot: str with the
    :param output_path:
    :return:
    """
    from pygraphviz import AGraph
    graph = AGraph().from_string(dot)
    graph.draw(path=output_path, prog='dot')

	def _render(self, costs=False, word_probs=False, highlight_best=False):	
		from pygraphviz import AGraph
                graph = AGraph(directed=True)
                for node_id, node_label in self.nodes.iteritems():
                        attributes = self._node_attr(node_id, costs=costs, word_probs=word_probs)
			graph.add_node(node_id, **attributes)
                for (parent_node_id, child_node_id) in self.edges:
                        graph.add_edge(parent_node_id, child_node_id)
		self.graph = graph
		if highlight_best:
			self._highlight_best()

 def __call__(self):
     self.request.response.setHeader('Content-Type', 'image/svg+xml')
     self.request.response.setHeader('Content-Disposition',
                                     'inline; filename=%s.svg' % \
                                     self.context.getId())
     tfile = tempfile.NamedTemporaryFile(suffix='.svg')
     gv = generate_gv(self.context)
     ag = AGraph(string=gv)
     ag.layout()
     ag.draw(path=tfile, format='svg', prog='dot')
     tfile.seek(0)
     return tfile.read()

def startGraph():
    # We maintain this globally to make it accessible, pylint: disable=global-statement
    global graph

    if Options.shallCreateGraph():
        try:
            from pygraphviz import AGraph  # pylint: disable=I0021,import-error

            graph = AGraph(name="Optimization", directed=True)
            graph.layout()
        except ImportError:
            warning("Cannot import pygraphviz module, no graphing capability.")

 def to_dot(self, filename, edges):
     from pygraphviz import AGraph
     dot = AGraph(directed=True)
     for n in edges.keys():
         dot.add_node(str(n))
         if lib.qcgc_arena_get_blocktype(ffi.cast("cell_t *", n)) not in [
                 lib.BLOCK_BLACK, lib.BLOCK_WHITE]:
             node = dot.get_node(str(n))
             node.attr['color'] = 'red'
     for n in edges.keys():
         if edges[n] is not None:
             dot.add_edge(str(n), str(edges[n]))
     dot.layout(prog='dot')
     dot.draw(filename)

def draw_workflow(filename, workflow):
    dot = AGraph(directed=True, strict=False)  # (comment="Computing scheme")
    for i, n in workflow.nodes.items():
        dot.add_node(i, label="{0} \n {1}".format(n.foo.__name__, _format_arg_list(n.bound_args.args, None)))

    for i in workflow.links:
        for j in workflow.links[i]:
            dot.add_edge(i, j[0], j[1].name)  # , headlabel=j[1].name, labeldistance=1.8)
    dot.layout(prog="dot")

    dot.draw(filename)

    def run(self):
        options = self.options
        filename = self.arguments[0]
        if self.content:
            content = u'\n'.join(self.content)
            ofilename = filename + '.' + self.outputformat
        else:
            content = open(filename).read().decode(options.get('encoding','utf-8'))
            ofilename = os.path.splitext(filename)[0] + '.' + self.outputformat

        g = AGraph(string=content)
        g.layout(prog='dot')
        opath = os.path.join(OUTPUT_DIR, ofilename)
        g.draw(opath, 'png')
        self.arguments[0] = opath
        return super(GraphvizBlock, self).run()