python类AGraph()的实例源码

def graphviz(elem, doc):
    if type(elem) == CodeBlock and 'graphviz' in elem.classes:
        code = elem.text
        caption = "caption"
        G = pygraphviz.AGraph(string=code)
        G.layout()
        filename = sha1(code)
        filetype = {'html': 'png', 'latex': 'pdf'}.get(doc.format, 'png')
        alt = Str(caption)
        src = imagedir + '/' + filename + '.' + filetype
        if not os.path.isfile(src):
            try:
                os.mkdir(imagedir)
                sys.stderr.write('Created directory ' + imagedir + '\n')
            except OSError:
                pass
            G.draw(src)
            sys.stderr.write('Created image ' + src + '\n')
        return Para(Image(alt, url=source, title=''))

def __init__(self, _parser, _lst_obj_ast, is_dominator=True):
        self._parser = _parser
        self._lst_obj_ast = _lst_obj_ast
        self._name = os.path.split(_parser.working_path)[1]
        self.is_dominator = is_dominator

        if is_dominator:
            self.file_path = os.path.join(_parser.graph_path, self._name + ".dom.dot")
            self.file_path_svg = os.path.join(_parser.graph_path, self._name + ".dom.dot.svgz")
            self._cfg_name = "DOMINATOR " + self._name
            self.stmt_ref = statement.ref_stmt["dominator"]
        else:
            self.file_path = os.path.join(_parser.graph_path, self._name + ".post_dom.dot")
            self.file_path_svg = os.path.join(_parser.graph_path, self._name + ".post_dom.dot.svgz")
            self._cfg_name = "POST-DOMINATOR " + self._name
            self.stmt_ref = statement.ref_stmt["post_dominator"]

        self.g = pgv.AGraph(name=self._cfg_name, directed=True)

def get_graph(self, title=None):
        """ Generate a DOT graph with pygraphviz, returns an AGraph object
        Args:
            title (string): Optional title for the graph.
        """
        if not pgv:
            raise Exception('AGraph diagram requires pygraphviz')

        if title is None:
            title = self.__class__.__name__
        elif title is False:
            title = ''

        fsm_graph = pgv.AGraph(label=title, compound=True, **self.machine_attributes)
        fsm_graph.node_attr.update(self.style_attributes['node']['default'])

        # For each state, draw a circle
        self._add_nodes(self.machine.states, fsm_graph)

        self._add_edges(self.machine.events, fsm_graph)

        setattr(fsm_graph, 'style_attributes', self.style_attributes)

        return fsm_graph

def plot_similarity_graph(self, show_edges=False):
        '''(trial) visualize similarity using GraphViz'''
        g = pygraphviz.AGraph(directed=False, overlap='scale', splines=True)
        g.node_attr['shape'] = 'plaintext'
        g.node_attr['fontsize'] = '12'
        if show_edges:
            g.edge_attr['color'] = 'lightgrey'
            g.edge_attr['fontcolor'] = 'grey'
            g.edge_attr['fontsize'] = '8'
        else:
            g.edge_attr['style'] = 'invis'
        for crawl1 in sorted(self.similarity['url']):
            for crawl2 in sorted(self.similarity['url'][crawl1]):
                similarity = self.similarity['url'][crawl1][crawl2]
                distance = 1.0 - similarity
                g.add_edge(MonthlyCrawl.short_name(crawl1),
                           MonthlyCrawl.short_name(crawl2),
                           len=(distance),
                           label='{0:.2f}'.format(distance))
        g.write(os.path.join(PLOTDIR, 'crawlsimilarity_url.dot'))
        g.draw(os.path.join(PLOTDIR, 'crawlsimilarity_url.svg'), prog='fdp')

def graphviz(self, root_id=None):
        g = pgv.AGraph(directed='True')               

        # Breadth-first traversal from root
        visited_ids = Set()
        curr_id = root_id
        q = Queue()
        q.put(curr_id)
        while not q.empty():
            curr_id = q.get()
            visited_ids.add(curr_id)                    
            for sub_id in self.id_to_term[curr_id].inv_is_a():
                if not sub_id in visited_ids:
                    g.add_edge(self.id_to_term[curr_id].name, 
                        self.id_to_term[sub_id].name)
                    q.put(sub_id)
        print str(g)

def layout(self, prog='dot', factor=8, offset=0):
        """Use GraphViz to auto-layout modules."""
        if pgv is not None:
            g = pgv.AGraph(self.graph(), directed=True, strict=False)
            g.layout(prog=prog)
            for node in g.nodes():
                x, y = node.attr['pos'].split(',')
                x, y = int(float(x)), int(float(y))
                idx = int(node)
                mod = self.modules[idx]
                if isinstance(factor, int):
                    xfactor, yfactor = factor, factor
                else:
                    xfactor, yfactor = factor
                if isinstance(offset, int):
                    xoffset, yoffset = offset, offset
                else:
                    xoffset, yoffset = offset
                mod.x = x * xfactor + xoffset
                mod.y = y * yfactor + yoffset
            return True
        else:
            logging.warning('GraphViz not available; could not auto-layout.')
            return False

def visualize(graph, output_path="a.png"):
    """visualize(graph, **kwargs) -> None
        Graph/Merger graph -> the graph/Merger that will be visualized
        string output_path-> the output path of the image
    """

    if isinstance(graph, Merger): graph = Merger.G
    G = pgv.AGraph(directed=graph.directed)

    G.add_nodes_from([i for i in xrange(1, len(graph.edges))])
    for edge in graph.iterate_edges():
        G.add_edge(edge.start, edge.end, label=edge.weight)

    G.node_attr['shape'] = 'egg'
    G.node_attr['width'] = '0.25'
    G.node_attr['height'] = '0.25'
    G.edge_attr['arrowhead'] = 'open'

    G.layout(prog='dot')
    G.draw(output_path)

def main():
    for gate_name, gate_f in (
            ("nor", lambda a, b: not (a or b)),
            ("nand", lambda a, b: not (a and b))
            ):
        for in1, in2 in ((False, False), (False, True), (True, True)):
            result = gate_f(in1, in2)
            g = pgv.AGraph(directed=True)

            g.add_node("in1", label=str(in1).upper(), **params[in1])
            g.add_node("in2", label=str(in2).upper(), **params[in2])
            g.add_node("gate", label="{}\n{}".format(gate_name, str(result).upper()), **params[result])
            g.add_node("result", style="invis")

            g.add_edge("in1", "gate", **params[in1])
            g.add_edge("in2", "gate", **params[in2])
            g.add_edge("gate", "result", **params[result])

            g.layout(prog='dot')
            g.draw("logic_example_autogen_{}_{}_{}.pdf".format(gate_name, in1, in2))

def __init__(self, seed, enabled=True):
        self.enabled = enabled
        if self.enabled:
            import pygraphviz as pgv
            self.file = FuzzerConfiguration().argument_values['work_dir'] + "/graph.dot"
            self.dot = pgv.AGraph(directed=True, strict=True)
            self.dot.graph_attr['epsilon'] = '0.0008'
            self.dot.graph_attr['defaultdist'] = '2'
            self.dot.write(self.file)

            for data in seed:
                self.dot.add_edge(None, str(data))

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 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 _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 draw(self, nth=None):
        if self.get_root() is None:
            with open("test_dot.dot", "w") as dfile:
                dfile.write("strict digraph {\n\tnode [shape = record,height=.1];\n}")
            pgv.AGraph("test_dot.dot").draw(self.file_path, prog="dot", format="png")
        else:
            code = lambda x: "n" + str(abs(x)) if x < 0 else "p" + str(abs(x))
            self.graph = {}
            self.get_graph(self.get_root())
            dfile = open("test_dot.dot", "w")
            dfile.write("strict digraph {\n\tnode [shape = record,height=.1];\n")
            for key in self.graph:
                if nth is not None and nth == key:
                    dfile.write(
                        "\tnode{0} [label = \"<f0> |<f1> {1}|<f2> \"] [style=filled ,fillcolor = green];\n".format(
                            code(key), key))
                else:
                    dfile.write("\tnode{0} [label = \"<f0> |<f1> {1}|<f2> \"];\n".format(code(key), key))

            for key in self.graph:
                for value in self.graph[key]:
                    dfile.write("\t\"node{0}\":{1}->\"node{2}\":f1;\n".format(code(key), "f0"
                    if self.graph[key][value]['child_status'] == 'left'
                    else "f2", code(value)))

            dfile.write("}")
            dfile.close()
            pgv.AGraph("test_dot.dot").draw(self.file_path, prog="dot", format="png")

def load_automata(path):
    graph_file = open(path, 'ro');
    G = pgv.AGraph("".join(graph_file.readlines()))
    graph_file.close()
    return G

def transform():
    graph = pgv.AGraph(directed=True, strict=True)
    with open("test.json", "r") as f:
        json_data = json.loads(f.read())

    # print(json.dumps(json_data, indent=2))
    travel_json(json_data, graph)
    # A.add_edge(1, 2)
    print(graph.string())
    graph.layout('dot')
    graph.draw('test.png')

def graphviz(key, value, format, meta):
    if key == 'CodeBlock':
        [[ident, classes, keyvals], code] = value
        caption = "caption"

        if "graphviz" in classes:
            G = pygraphviz.AGraph(string=code)
            layout = "dot"
            for elem in keyvals:
                if elem[0] == "layout":
                    layout = elem[1]
            G.layout(layout)
            filename = sha1(code)
            if format == "html":
                filetype = "png"
            elif format == "latex":
                filetype = "png"
            else:
                filetype = "png"
            alt = Str(caption)
            src = imagedir + '/' + filename + '.' + filetype
            if not os.path.isfile(src):
                try:
                    os.mkdir(imagedir)
                except OSError:
                    pass
                G.draw(src)
                out(src)
            tit = ""
            return Para([Image(['', [], []], [alt], [src, tit])])

def get_graph(string):
    """ Create a graph from a DOT string """
    dot = pg.AGraph(string)
    return nx.drawing.nx_agraph.from_agraph(dot)

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 generate_process_flowchart(process):
        file_template = """
            strict digraph {
                rankdir=TB;
                graph [ratio="auto"
                    label="{{ name }}"
                    labelloc=t
                    ];
                node [shape = ellipse];
                {
                    node [shape=diamond label="Router"];
                    {% for node in router_nodes %}
                    {{ node.name }};
                    {% endfor %}
                }
                edge [fontsize=14]
                {% for transition in transitions %}
                "{{ transition.input_node.name }}" -> "{{ transition.output_node.name }}"
                [label="{{ transition.name }} {% if transition.get_condition_descn %}: {% endif %} {{ transition.get_condition_descn }}"] ;
                {% endfor %}
            }
        """  # NOQA
        transitions = process.transition_set.all()
        router_nodes = process.node_set.filter(node_type='router')
        request = Context(
            {
                'name': process.name,
                'router_nodes': router_nodes,
                'transitions': transitions
            }
        )
        t = Template(file_template)
        G = pgv.AGraph(string=t.render(request))
        return G

def node_data_call_back(self,nodeDataArray):
        graph = pygr.AGraph()
        show_name = self.show_node_name
        for node in nodeDataArray.nodes:
            my_color,my_shape = self.read_attributes(node)
            my_label = node.myName + "\n" + "("+node.myType+")"

            if node.myStatus != 3 \
                    or self.draw_all_nodes == True \
                    or node.myName == show_name \
                    or node.parentName == show_name:

                # avoid an overwrinting of inactive node on an active node
                if graph.has_node(node.myName) == False \
                        or node.myStatus != 3:
                    graph.add_node(node.myName,
                        style="filled",
                        fillcolor=my_color,
                        shape=my_shape,
                        label=my_label)

                graph.add_edge(node.myName,node.parentName)

        dot_string = graph.to_string()

        # use same sentences to correct centering
        if self.centering == True:
            self._widget.xdot_widget.set_dotcode(dot_string, center=True)
            self.centering = False
        else:
            self._widget.xdot_widget.set_dotcode(dot_string, center=False)

def graphviz(key, value, format, meta):
    if key == 'CodeBlock':
        [[ident, classes, keyvals], code] = value
        caption = "caption"
        if "graphviz" in classes:
            G = pygraphviz.AGraph(string=code)
            G.layout()
            filename = sha1(code)
            if format == "html":
                filetype = "png"
            elif format == "latex":
                filetype = "pdf"
            else:
                filetype = "png"
            alt = Str(caption)
            src = imagedir + '/' + filename + '.' + filetype
            if not os.path.isfile(src):
                try:
                    os.mkdir(imagedir)
                    sys.stderr.write('Created directory ' + imagedir + '\n')
                except OSError:
                    pass
                G.draw(src)
                sys.stderr.write('Created image ' + src + '\n')
            tit = ""
            return Para([Image(['', [], []], [alt], [src, tit])])

def draw_graph(digraph):
    def name(p):
        return "%r" % p
    G = pgz.AGraph(directed=True)
    for x in digraph:
        for y in digraph.parent_nodes(x):
            G.add_edge(name(y), name(x))
    G.layout('dot')
    G.draw("ewrap.png")

def __init__(self, _parser, _lst_obj_ast):
        self._parser = _parser
        self._lst_obj_ast = _lst_obj_ast
        self._name = os.path.split(_parser.working_path)[1]
        self.file_path = os.path.join(_parser.graph_path, self._name + ".dot")
        self._cfg_name = "CFG " + self._name
        self.g = pgv.AGraph(name=self._cfg_name, directed=True)

def __init__(self, _parser, _lst_obj_ast):
        self._parser = _parser
        self._lst_obj_ast = _lst_obj_ast
        self._name = os.path.split(_parser.working_path)[1]
        self.file_path = os.path.join(_parser.graph_path, self._name + ".dot")
        self._uml_name = "UML " + self._name
        file_path = os.path.join(_parser.graph_path, self._uml_name)
        self.g = pgv.AGraph(name=file_path, directed=True)

def visualization(metadata, filename):
    print "--- VISUALIZATION ---"
    g = graph.AGraph(directed=True)
    for k, v in metadata.items(): 
        for x in xrange(len(v)):
            node, zf = v[x].split('^')
            g.add_edge(k, node, len="2.1", label=zf, rankdir="LR") 
    filename = os.path.basename(filename)
    g.layout(prog='dot')
    picture = "%s-%s.png" % (filename, "image")
    print "[+] Generating %s" % picture
    g.draw(picture)

def visualization(metadata, filename):
    print "--- VISUALIZATION ---"
    g = graph.AGraph(directed=True)
    for k, v in metadata.items(): 
        for x in xrange(len(v)):
            node, zf = v[x].split('^')
            g.add_edge(k, node, len="2.1", label=zf, rankdir="LR") 
            #print "adding %s -> %s" % (k, node)
    filename = os.path.basename(filename)
    g.layout(prog='dot')
    picture = "%s-%s.png" % (filename, "image")
    print "[+] Generating %s" % picture
    g.draw(picture)

def execute(self, *args, **kwargs):
        try:
            import pygraphviz as pgv
        except ImportError:
            print "This command requires pygraphviz"
            return

        if len(args) == 0:
            resources = ResourceQuery().get_all_resources()
        else:
            resources = []

            def iterate(record):
                res = record.to_resource()
                resources.append(res)
                for p in record.parents.all():
                    p_res = iterate(p)
                    res._parents.append(p_res)
                return res

            start_id = int(args[0])
            start_record = StorageResourceRecord.objects.get(pk = start_id)
            iterate(start_record)
        G = pgv.AGraph(directed=True)
        for r in resources:
            G.add_node(r._handle, label="%s:%s:%s" % (r._handle, r._meta.label, r.get_label()))

        for r in resources:
            for p in r.get_parents():
                G.add_edge(r._handle, p._handle)

        G.layout(prog='dot')
        output_file = 'resources.png'
        G.draw(output_file)
        print "Wrote graph to %s" % output_file

def __init__(self, *args, **kwargs):
        self.seen = []
        super(AGraph, self).__init__(*args, **kwargs)

def get_graph(self, title=None, force_new=False):
        if title is None:
            title = self.title
        if not hasattr(self, 'graph') or force_new:
            self.graph = AGraph(self).get_graph(title)

        return self.graph

def graphviz_export(self, filename, dpi = 300):

    import pygraphviz as pgv
    G = pgv.AGraph(directed=True)
    G.node_attr['shape'] = 'box'
    # G.graph_attr['size'] = '2!,2!' # use for animations only
    # G.graph_attr['dpi'] = str(dpi)

    parent = self.root
    G.add_node(str(parent))
    S = []

    while parent.is_feature or len(S) > 0:
      if parent.is_feature:
        S.append(parent)
        child = parent.l
        label = 'T'

      else:
        parent = S.pop()
        child = parent.r
        label = 'F'

      G.add_node(str(child))
      G.add_edge(str(parent), str(child), label=label)
      parent = child

    G.layout(prog='dot')
    G.draw(filename)