Python pydotplus.Node方法代码示例

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_unicode_ids(self):

        node1 = '"aánñoöüé€"'
        node2 = '"îôø®çßΩ"'

        g = pydotplus.Dot()
        g.set_charset('latin1')
        g.add_node(pydotplus.Node(node1))
        g.add_node(pydotplus.Node(node2))
        g.add_edge(pydotplus.Edge(node1, node2))

        self.assertEqual(g.get_node(node1)[0].get_name(), node1)
        self.assertEqual(g.get_node(node2)[0].get_name(), node2)

        self.assertEqual(g.get_edges()[0].get_source(), node1)
        self.assertEqual(g.get_edges()[0].get_destination(), node2)

        g2 = pydotplus.graph_from_dot_data(g.to_string())

        self.assertEqual(g2.get_node(node1)[0].get_name(), node1)
        self.assertEqual(g2.get_node(node2)[0].get_name(), node2)

        self.assertEqual(g2.get_edges()[0].get_source(), node1)
        self.assertEqual(g2.get_edges()[0].get_destination(), node2) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def bpmn_diagram_to_png(bpmn_diagram, file_name):
    """
    Create a png picture for given diagram

    :param bpmn_diagram: an instance of BPMNDiagramGraph class,
    :param file_name: name of generated file.
    """
    g = bpmn_diagram.diagram_graph
    graph = pydotplus.Dot()

    for node in g.nodes(data=True):

        if node[1].get(consts.Consts.type) == consts.Consts.task:
            n = pydotplus.Node(name=node[0], shape="box", style="rounded", label=node[1].get(consts.Consts.node_name))
        elif node[1].get(consts.Consts.type) == consts.Consts.exclusive_gateway:
            n = pydotplus.Node(name=node[0], shape="diamond", label=node[1].get(consts.Consts.node_name))
        else:
            n = pydotplus.Node(name=node[0], label=node[1].get(consts.Consts.node_name))
        graph.add_node(n)

    for edge in g.edges(data=True):
        e = pydotplus.Edge(src=edge[0], dst=edge[1], label=edge[2].get(consts.Consts.name))
        graph.add_edge(e)

    graph.write(file_name + ".png", format='png') 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def __repr__(self):
        return 'Node(address_id:{}, weight:{}, outgoing_edges:{})'.format(self.address_id, self.weight, [str(edge) for edge in self.outgoing_edges]) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def push_node_stmt(s, loc, toks):

    if len(toks) == 2:
        attrs = toks[1].attrs
    else:
        attrs = {}

    node_name = toks[0]
    if isinstance(node_name, list) or isinstance(node_name, tuple):
        if len(node_name) > 0:
            node_name = node_name[0]

    n = pydotplus.Node(str(node_name), **attrs)
    return n 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_add_style(self):

        node = pydotplus.Node('mynode')
        node.add_style('abc')
        self.assertEqual(node.get_style(), 'abc')
        node.add_style('def')
        self.assertEqual(node.get_style(), 'abc,def')
        node.add_style('ghi')
        self.assertEqual(node.get_style(), 'abc,def,ghi') 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_create_simple_graph_with_node(self):

        g = pydotplus.Dot()
        g.set_type('digraph')
        node = pydotplus.Node('legend')
        node.set("shape", 'box')
        g.add_node(node)
        node.set('label', 'mine')

        self.assertEqual(
            g.to_string(),
            'digraph G {\nlegend [label=mine, shape=box];\n}\n'
        ) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_numeric_node_id(self):

        self._reset_graphs()

        self.graph_directed.add_node(pydotplus.Node(1))

        self.assertEqual(self.graph_directed.get_nodes()[0].get_name(), '1') 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_quoted_node_id(self):

        self._reset_graphs()

        self.graph_directed.add_node(pydotplus.Node('"node"'))

        self.assertEqual(
            self.graph_directed.get_nodes()[0].get_name(), '"node"'
        ) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_quoted_node_id_to_string_no_attributes(self):

        self._reset_graphs()

        self.graph_directed.add_node(pydotplus.Node('"node"'))

        self.assertEqual(
            self.graph_directed.get_nodes()[0].to_string(), '"node";'
        ) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_keyword_node_id(self):

        self._reset_graphs()

        self.graph_directed.add_node(pydotplus.Node('node'))

        self.assertEqual(self.graph_directed.get_nodes()[0].get_name(), 'node') 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_keyword_node_id_to_string_with_attributes(self):

        self._reset_graphs()

        self.graph_directed.add_node(pydotplus.Node('node', shape='box'))

        self.assertEqual(
            self.graph_directed.get_nodes()[0].to_string(), 'node [shape=box];'
        ) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_names_of_a_thousand_nodes(self):

        self._reset_graphs()

        names = set(['node_%05d' % i for i in xrange(10 ** 4)])

        for name in names:

            self.graph_directed.add_node(pydotplus.Node(name, label=name))

        self.assertEqual(
            set([n.get_name() for n in self.graph_directed.get_nodes()]), names
        ) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def test_quoting(self):
        import string
        g = pydotplus.Dot()
        g.add_node(pydotplus.Node("test", label=string.printable))
        data = g.create(format='jpe')
        self.assertEqual(len(data) > 0, True) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def add_elements(g, toks,
                 defaults_graph=None,
                 defaults_node=None,
                 defaults_edge=None):
    if defaults_graph is None:
        defaults_graph = {}
    if defaults_node is None:
        defaults_node = {}
    if defaults_edge is None:
        defaults_edge = {}

    for elm_idx, element in enumerate(toks):
        if isinstance(element, (pydotplus.Subgraph, pydotplus.Cluster)):
            add_defaults(element, defaults_graph)
            g.add_subgraph(element)

        elif isinstance(element, pydotplus.Node):
            add_defaults(element, defaults_node)
            g.add_node(element)

        elif isinstance(element, pydotplus.Edge):
            add_defaults(element, defaults_edge)
            g.add_edge(element)

        elif isinstance(element, ParseResults):
            for e in element:
                add_elements(
                    g, [e], defaults_graph, defaults_node, defaults_edge
                )

        elif isinstance(element, DefaultStatement):
            if element.default_type == 'graph':
                default_graph_attrs = pydotplus.Node('graph', **element.attrs)
                g.add_node(default_graph_attrs)

            elif element.default_type == 'node':
                default_node_attrs = pydotplus.Node('node', **element.attrs)
                g.add_node(default_node_attrs)

            elif element.default_type == 'edge':
                default_edge_attrs = pydotplus.Node('edge', **element.attrs)
                g.add_node(default_edge_attrs)
                defaults_edge.update(element.attrs)

            else:
                raise ValueError(
                    "Unknown DefaultStatement: %s " % element.default_type
                )

        elif isinstance(element, P_AttrList):
            g.obj_dict['attributes'].update(element.attrs)

        else:
            raise ValueError("Unknown element statement: %r" % element) 

# 需要导入模块: import pydotplus [as 别名]
# 或者: from pydotplus import Node [as 别名]
def push_edge_stmt(str, loc, toks):
    tok_attrs = [a for a in toks if isinstance(a, P_AttrList)]
    attrs = {}

    for a in tok_attrs:
        attrs.update(a.attrs)

    e = []

    if isinstance(toks[0][0], pydotplus.Graph):
        n_prev = pydotplus.frozendict(toks[0][0].obj_dict)
    else:
        n_prev = toks[0][0] + do_node_ports(toks[0])

    if isinstance(toks[2][0], ParseResults):
        n_next_list = [[n.get_name()] for n in toks[2][0]]
        for n_next in [n for n in n_next_list]:
            n_next_port = do_node_ports(n_next)
            e.append(pydotplus.Edge(n_prev, n_next[0] + n_next_port, **attrs))

    elif isinstance(toks[2][0], pydotplus.Graph):
        e.append(
            pydotplus.Edge(
                n_prev,
                pydotplus.frozendict(toks[2][0].obj_dict),
                **attrs
            )
        )

    elif isinstance(toks[2][0], pydotplus.Node):
        node = toks[2][0]

        if node.get_port() is not None:
            name_port = node.get_name() + ":" + node.get_port()
        else:
            name_port = node.get_name()

        e.append(pydotplus.Edge(n_prev, name_port, **attrs))

    elif isinstance(toks[2][0], type('')):
        for n_next in [n for n in tuple(toks)[2::2]]:
            if isinstance(n_next, P_AttrList) or \
                    not isinstance(n_next[0], type('')):
                continue

            n_next_port = do_node_ports(n_next)
            e.append(pydotplus.Edge(n_prev, n_next[0] + n_next_port, **attrs))

            n_prev = n_next[0] + n_next_port

    else:
        # UNEXPECTED EDGE TYPE
        pass

    return e