def plot(root, to_file='vct_tree.png'):
dot = pydot.Dot()
dot.set('rankdir', 'TB')
dot.set('concentrate', True)
dot.set_node_defaults(shape='record')
root.id = 0
label = 'root\nproof:{:d} disproof:{:d}'.format(root.proof, root.disproof)
dot.add_node(pydot.Node(root.id, label=label))
node_stack = []
node_stack.append(root)
count = 0
while len(node_stack):
node = node_stack.pop()
if node.parent is not None:
parent_id = node.parent.id
node_id = node.id
dot.add_edge(pydot.Edge(parent_id, node_id))
for position, child_node in node.children.items():
count += 1
child_node.id = count
label = str(position) + '\nproof:{:d} disproof:{:d}'.format(
child_node.proof, child_node.disproof)
dot.add_node(pydot.Node(child_node.id, label=label))
node_stack.append(child_node)
_, extension = os.path.splitext(to_file)
if not extension:
extension = 'png'
else:
extension = extension[1:]
dot.write(to_file, format=extension)
def make_graph(edge_list, directed=False):
if directed:
graph = pydot.Dot(graph_type='digraph')
else:
graph = pydot.Dot(graph_type='graph')
for edge in edge_list:
id1 = str(edge[0][0])
label1 = str(edge[0][1])
id2 = str(edge[1][0])
label2 = str(edge[1][1])
graph.add_node(
pydot.Node(id1,
label='<<font face="MS Gothic">%s</font>>' %
label1.rstrip("\r\n")))
graph.add_node(
pydot.Node(id2,
label='<<font face="MS Gothic">%s</font>>' %
label2.rstrip("\r\n")))
graph.add_edge(pydot.Edge(id1, id2))
return graph
def lazy_create_node(node):
if node.uid in function_nodes: # dot node already exists
return function_nodes[node.uid]
if node.is_primitive and not node.is_block and len(
node.outputs
) == 1 and node.output.name == node.name: # skip the node name if redundant
op_name = primitive_op_map.get(node.op_name, node.op_name)
render_as_primitive = len(op_name) <= 4
size = 0.4 if render_as_primitive else 0.6
cur_node = pydot.Node(
node.uid,
label='"' + op_name + '"',
shape='ellipse' if render_as_primitive else 'box',
fixedsize='true' if render_as_primitive else 'false',
height=size,
width=size,
fontsize=20
if render_as_primitive and len(op_name) == 1 else 12,
penwidth=4 if node.op_name != 'Pass'
and node.op_name != 'ParameterOrder' else 1)
# TODO: Would be cool, if the user could pass a dictionary with overrides. But maybe for a later version.
else:
f_name = '\n' + node.name + '()' if node.name else ''
cur_node = pydot.Node(
node.uid,
label='"' + node.op_name + f_name + '"',
fixedsize='true',
height=1,
width=1.3,
penwidth=4 if node.op_name != 'Pass'
and node.op_name != 'ParameterOrder' else 1)
dot_object.add_node(cur_node)
function_nodes[node.uid] = cur_node
return cur_node
def mnn_to_dot(mnn_file):
"load a mnn file and create a dot file"
if not os.path.exists(mnn_file):
return None
dot = pydot.Dot()
dot.set('rankdir', 'TB')
dot.set('concentrate', True)
dot.set_node_defaults(shape='record')
with open(mnn_file, 'rb') as f:
buf = f.read()
f.close()
buf = bytearray(buf)
net = Net.Net.GetRootAsNet(buf, 0)
op_num = net.OplistsLength()
for idx in range(op_num):
op = net.Oplists(idx)
name = "op_" + str(idx)
op_type = op.Type()
label = OpName.optype_to_name(op_type)
main_type = op.MainType()
if main_type == OpParameter.OpParameter.Convolution2D:
union_conv2d = Convolution2D.Convolution2D()
union_conv2d.Init(op.Main().Bytes, op.Main().Pos)
common = union_conv2d.Common()
KernelX = common.KernelX()
KernelY = common.KernelY()
input_channels = common.InputCount()
output_channels = common.OutputCount()
label += "\nshape:" + str(input_channels) + "*" + str(output_channels) \
+ "*" + str(KernelX) + "*" + str(KernelY)
if op_type != OpType.OpType.Input:
node = pydot.Node(name, label=label, shape="egg", color='blue')
dot.add_node(node)
ts_num = net.TensorNameLength()
for idx in range(ts_num):
ts_name = net.TensorName(idx)
name = "tensor_" + str(idx)
label = ts_name
node = dot.get_node(name)
node = pydot.Node(name, label=label, shape="record", color='red')
dot.add_node(node)
for idx in range(op_num):
op = net.Oplists(idx)
name_op = "op_" + str(idx)
input_len = op.InputIndexesLength()
output_len = op.OutputIndexesLength()
for idx_ts in range(input_len):
name_tensor = "tensor_" + str(op.InputIndexes(idx_ts))
add_edge(dot, name_tensor, name_op)
for idx_ts in range(output_len):
name_tensor = "tensor_" + str(op.OutputIndexes(idx_ts))
add_edge(dot, name_op, name_tensor)
return dot
def draw(parent_name, child_name, graph, parent_hash):
"""Draw parent and child nodes. Create and return new hash\n
key declared to a child node."""
parent_node = pydot.Node(parent_hash, label=parent_name, shape='box')
child_hash = str(uuid.uuid4()) # create hash key
child_node = pydot.Node(child_hash, label=child_name, shape='box')
graph.add_node(parent_node)
graph.add_node(child_node)
graph.add_edge(pydot.Edge(parent_node, child_node))
return child_hash
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 element in toks:
if isinstance(element, (pydot.Subgraph, pydot.Cluster)):
add_defaults(element, defaults_graph)
g.add_subgraph(element)
elif isinstance(element, pydot.Node):
add_defaults(element, defaults_node)
g.add_node(element)
elif isinstance(element, pydot.Edge):
add_defaults(element, defaults_edge)
g.add_edge(element)
elif isinstance(element, pyparsing.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 = pydot.Node('graph', **element.attrs)
g.add_node(default_graph_attrs)
elif element.default_type == 'node':
default_node_attrs = pydot.Node('node', **element.attrs)
g.add_node(default_node_attrs)
elif element.default_type == 'edge':
default_edge_attrs = pydot.Node('edge', **element.attrs)
g.add_node(default_edge_attrs)
defaults_edge.update(element.attrs)
else:
raise ValueError("Unknown DefaultStatement: {0} ".format(
element.default_type))
elif isinstance(element, P_AttrList):
g.obj_dict['attributes'].update(element.attrs)
else:
raise ValueError("Unknown element statement: %r" % element)
def to_pydot_graph(dag, sub_graph=False, input_edge=None):
import pydot_ng as pydot
gid = dag['input'][2][:-2]
graph = pydot.Dot(graph_type='digraph')
if sub_graph:
graph = pydot.Cluster(label='booster')
dag_nx = dag_to_nx(dag)
for n in dag_nx.nodes():
label = 'input' if dag[n][1] == 'input' else (
dag[n][1][0] + ('(' + ','.join('{}={}'.format(k, v)
for k, v in dag[n][1][1].items()) +
')' if dag[n][1][1] else ''))
label = 'input' if dag[n][1] == 'input' else (
dag[n][1][0] + ('(' + ','.join('{}'.format(v)
for k, v in dag[n][1][1].items()) +
')' if dag[n][1][1] else ''))
node_name = n
if label == 'input':
if sub_graph:
continue
node_name = label + gid
if input_edge != None:
outs = dag[n][2]
if not isinstance(outs, list):
outs = [outs]
for o in outs:
edge = pydot.Edge(input_edge, o)
graph.add_edge(edge)
if dag[n][1][0] == 'booster':
graph.add_node(pydot.Node(n, label='booster'))
for sd in dag[n][1][1]['sub_dags']:
subgraph = to_pydot_graph(sd,
sub_graph=True,
input_edge=dag[n][0])
graph.add_subgraph(subgraph)
else:
node = pydot.Node(node_name, label=label)
graph.add_node(node)
for (f, t) in dag_nx.edges():
if f == 'input':
if input_edge == None:
f = 'input' + gid
else:
f = input_edge
edge = pydot.Edge(f, t)
graph.add_edge(edge)
return graph
def edges2graph(edge_list):
graph = pydot.Dot(graph_type='digraph')
for edge in edge_list:
id1 = str(edge[0][0])
label1 = str(edge[0][1])
id2 = str(edge[1][0])
label2 = str(edge[1][1])
graph.add_node(pydot.Node(id1,label = label1))
graph.add_node(pydot.Node(id2,label = label2))
graph.add_edge(pydot.Edge(id1,id2))
return graph
def graph_from_edges_ex(edge_list, directed=False):
if directed:
graph = pydot.Dot(graph_type="digraph")
else:
graph = pydot.Dot(graph_type="graph")
for edge in edge_list:
id1 = str(edge[0][0])
label1 = str(edge[0][1])
id2 = str(edge[1][0])
label2 = str(edge[1][1])
graph.add_node(pydot.Node(id1, label=label1))
graph.add_node(pydot.Node(id2, label=label2))
graph.add_edge(pydot.Edge(id1, id2))
return graph
def graph_4_edge(edges, gr_type='graph'):
graph = pydot.Dot(graph_type=gr_type)
for edge in edges:
id1 = str(edge[0][0])
label1 = str(edge[0][1])
id2 = str(edge[1][0])
label2 = str(edge[1][1])
graph.add_node(pydot.Node(id1, label=label1))
graph.add_node(pydot.Node(id2, label=label2))
graph.add_edge(pydot.Edge(id1, id2))
return graph
def graph_write(edgelist):
graph = pd.Dot(graph_type='digraph')
for edge in edgelist:
bef_num = str(edge[0][0])
aft_num = str(edge[1][0])
bef_word = str(edge[0][1])
aft_word = str(edge[1][1])
graph.add_node(pd.Node(bef_num, label=bef_word))
graph.add_node(pd.Node(aft_num, label=aft_word))
graph.add_edge(pd.Edge(bef_num, aft_num))
return graph
def visualization(sentence):
# 有向グラフ
graph = pydot.Dot(graph_type='digraph')
for chunk in sentence:
# dstから辿る
source_i = chunk.index
target_i = chunk.dst
graph.add_node(
pydot.Node(source_i,
label=pattern.sub("", sentence[source_i].morphstr)))
graph.add_node(
pydot.Node(target_i,
label=pattern.sub("", sentence[target_i].morphstr)))
graph.add_edge(pydot.Edge(source_i, chunk.dst))
graph.write_png('knock44.png')
def create_graph(graph_info):
dot = pydot.Dot()
for node in graph_info['nodes']:
dot.add_node(pydot.Node(node))
for node1, node2 in graph_info['edges']:
dot.add_edge(pydot.Edge(node1, node2))
return dot
def model_to_dot(model, show_shapes=False, show_layer_names=True):
dot = pydot.Dot()
dot.set('rankdir', 'TB')
dot.set('concentrate', True)
dot.set_node_defaults(shape='record')
if isinstance(model, Sequential):
if not model.built:
model.build()
model = model.model
layers = model.layers
# Create graph nodes.
for layer in layers:
layer_id = str(id(layer))
# Append a wrapped layer's label to node's label, if it exists.
layer_name = layer.name
class_name = layer.__class__.__name__
if isinstance(layer, Wrapper):
layer_name = '{}({})'.format(layer_name, layer.layer.name)
child_class_name = layer.layer.__class__.__name__
class_name = '{}({})'.format(class_name, child_class_name)
# Create node's label.
if show_layer_names:
label = '{}: {}'.format(layer_name, class_name)
else:
label = class_name
# Rebuild the label as a table including input/output shapes.
if show_shapes:
try:
outputlabels = str(layer.output_shape)
except:
outputlabels = 'multiple'
if hasattr(layer, 'input_shape'):
inputlabels = str(layer.input_shape)
elif hasattr(layer, 'input_shapes'):
inputlabels = ', '.join(
[str(ishape) for ishape in layer.input_shapes])
else:
inputlabels = 'multiple'
label = '%s\n|{input:|output:}|{{%s}|{%s}}' % (label, inputlabels,
outputlabels)
node = pydot.Node(layer_id, label=label)
dot.add_node(node)
# Connect nodes with edges.
for layer in layers:
layer_id = str(id(layer))
for i, node in enumerate(layer.inbound_nodes):
node_key = layer.name + '_ib-' + str(i)
if node_key in model.container_nodes:
for inbound_layer in node.inbound_layers:
inbound_layer_id = str(id(inbound_layer))
layer_id = str(id(layer))
dot.add_edge(pydot.Edge(inbound_layer_id, layer_id))
return dot
def test_names_of_a_thousand_nodes(digraph):
names = set(["node_%05d" % i for i in xrange(10 ** 4)])
for name in names:
digraph.add_node(pydot.Node(name, label=name))
assert set([n.get_name() for n in digraph.get_nodes()]) == names
def test_quoting():
import string
g = pydot.Dot()
g.add_node(pydot.Node("test", label=string.printable))
data = g.create(format="jpe")
assert len(data) > 0
def threadTree(self, graph, seen=None, col=0):
colors = ('red', 'green', 'blue', 'yellow', 'magenta', 'cyan')
if not seen: seen = []
if self in seen: return
seen.append(self)
new = not graph.get_node(self.ID)
if new:
graphnode = pydot.Node(self.ID, label=repr(self), shape=self.shape)
graphnode.set_style('dotted')
graph.add_node(graphnode)
label = len(self.next) - 1
for i, c in enumerate(self.next):
if not c: return
col = (col + 1) % len(colors)
col = 0 # FRT pour tout afficher en rouge
color = colors[col]
c.threadTree(graph, seen, col)
edge = pydot.Edge(self.ID, c.ID)
edge.set_color(color)
edge.set_arrowsize('.5')
# Les arr�tes correspondant aux coutures ne sont pas prises en compte
# pour le layout du graphe. Ceci permet de garder l'arbre dans sa repr�sentation
# "standard", mais peut provoquer des surprises pour le trajet parfois un peu
# tarabiscot� des coutures...
# En commantant cette ligne, le layout sera bien meilleur, mais l'arbre nettement
# moins reconnaissable.
edge.set_constraint('false')
if label:
edge.set_taillabel(str(i))
edge.set_labelfontcolor(color)
graph.add_edge(edge)
return graph
def plot_net(net, file_name='net.png', show_shapes=False, rankdir="TB"):
dot = pydot.Dot()
dot.set('rankdir', rankdir)
dot.set('concentrate', True)
dot.set_node_defaults(shape='recodr')
id_layer_name_pair = dict()
for i, layer in enumerate(net.all_layers):
layer_name = layer.name
layer_shape = layer.get_shape()
if show_shapes:
label = "%s\n %s" % (layer_name, str(layer_shape))
else:
label = layer_name
node = pydot.Node(i, label=label)
dot.add_node(node)
id_layer_name_pair[layer_name] = i
for key in net.net_tree:
if key in id_layer_name_pair.keys():
parent_id = id_layer_name_pair[key]
else:
continue
for child in net.net_tree[key]:
if child in id_layer_name_pair.keys():
child_id = id_layer_name_pair[child]
dot.add_edge(pydot.Edge(parent_id,child_id))
_, extension = os.path.splitext(file_name)
if not extension:
extension = 'png'
else:
extension = extension[1:]
dot.write(file_name, format=extension)
def _pydot_node_for_layer(self, layer, label):
"""
Returns the pydot.Node corresponding to the given layer.
`label` specify the name of the layer (only used if the layer isn't yet
associated with a pydot.Node)
"""
# Check if this already exists (will be the case for nodes that
# serve as input to more than one layer)
if layer in self.layer_to_pydotnode:
node = self.layer_to_pydotnode[layer]
else:
layer_id = 'layer%d' % self.idgen
self.idgen += 1
label = label + " (" + layer_typename(layer) + ")"
if self.show_shape:
# Build the label that will actually contain a table with the
# input/output
outputlabels = str(layer.output_shape)
if hasattr(layer, 'input_shape'):
inputlabels = str(layer.input_shape)
elif hasattr(layer, 'input_shapes'):
inputlabels = ', '.join(
[str(ishape) for ishape in layer.input_shapes])
else:
inputlabels = ''
label = "%s\n|{input:|output:}|{{%s}|{%s}}" % (
label, inputlabels, outputlabels)
node = pydot.Node(layer_id, label=label)
self.g.add_node(node)
self.layer_to_pydotnode[layer] = node
return node
def to_pydot(N, strict=True):
"""Return a pydot graph from a NetworkX graph N.
Parameters
----------
N : NetworkX graph
A graph created with NetworkX
Examples
--------
>>> import networkx as nx
>>> K5 = nx.complete_graph(5)
>>> P = nx.to_pydot(K5)
Notes
-----
"""
# set Graphviz graph type
if N.is_directed():
graph_type = 'digraph'
else:
graph_type = 'graph'
strict = N.number_of_selfloops() == 0 and not N.is_multigraph()
name = N.graph.get('name')
graph_defaults = N.graph.get('graph', {})
if name is None:
P = pydot.Dot(graph_type=graph_type, strict=strict, **graph_defaults)
else:
P = pydot.Dot('"%s"' % name, graph_type=graph_type, strict=strict,
**graph_defaults)
try:
P.set_node_defaults(**N.graph['node'])
except KeyError:
pass
try:
P.set_edge_defaults(**N.graph['edge'])
except KeyError:
pass
for n, nodedata in N.nodes_iter(data=True):
str_nodedata = dict((k, make_str(v)) for k, v in nodedata.items())
p = pydot.Node(make_str(n), **str_nodedata)
P.add_node(p)
if N.is_multigraph():
for u, v, key, edgedata in N.edges_iter(data=True, keys=True):
str_edgedata = dict((k, make_str(v)) for k, v in edgedata.items())
edge = pydot.Edge(make_str(u), make_str(v),
key=make_str(key), **str_edgedata)
P.add_edge(edge)
else:
for u, v, edgedata in N.edges_iter(data=True):
str_edgedata = dict((k, make_str(v)) for k, v in edgedata.items())
edge = pydot.Edge(make_str(u), make_str(v), **str_edgedata)
P.add_edge(edge)
return P
def make_graph(edges: list):
graph = pydot.Dot(graph_type='digraph') # digraph有効グラフの指定
for edge in edges:
id1 = edge[0][0]
label1 = edge[0][1]
id2 = edge[1][0]
label2 = edge[1][1]
# idがないと同じ文節が出たときに混ざってしまう
graph.add_node(pydot.Node(id1, label=label1))
graph.add_node(pydot.Node(id2, label=label2))
# 上で追加したノードをつなぐエッジを追加、idで判断
graph.add_edge(pydot.Edge(id1, id2))
return graph
def test_add_style(self):
node = pydot.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')
def graph_node(layers, dot, model, show_shapes=False, show_layer_names=False):
for l, layer in enumerate(layers):
layer_id = str(id(layer))
# Append a wrapped layer's label to node's label, if it exists.
layer_name = layer.name
class_name = layer.__class__.__name__
if class_name in [
"Dropout", "BatchNormalization", "Activation", "Flatten"
]:
continue
if class_name == "Model":
layer.layers[0].inbound_nodes = layer.inbound_nodes
graph_node(layer.layers, dot, layer, show_shapes=show_shapes)
continue
if isinstance(layer, Wrapper):
layer_name = '{}({})'.format(layer_name, layer.layer.name)
child_class_name = layer.layer.__class__.__name__
class_name = '{}({})'.format(class_name, child_class_name)
# Create node's label.
if show_layer_names:
label = '{}: {}'.format(layer_name, class_name.split("(")[1][:-1])
else:
label = class_name.split("(")[-1].split(")")[0]
# Rebuild the label as a table including input/output shapes.
if show_shapes:
try:
if len(layer.output_shape) > 2:
outputlabels = str(layer.output_shape[2:])
else:
outputlabels = str(layer.output_shape[1])
except:
outputlabels = 'multiple'
if hasattr(layer, 'input_shape'):
if len(layer.input_shape) > 2:
inputlabels = str(layer.input_shape[2:])
else:
inputlabels = str(layer.input_shape[1])
elif hasattr(layer, 'input_shapes'):
inputlabels = ', '.join(
[str(ishape) for ishape in layer.input_shapes])
else:
inputlabels = 'multiple'
label = '%s\n|{input:|output:}|{{%s}|{%s}}' % (label, inputlabels,
outputlabels)
if "Convolution" in class_name:
color = "red"
elif "Pooling" in class_name:
color = "blue"
else:
color = "green"
node = pydot.Node(layer_id, label=label, color=color)
dot.add_node(node)
def graph_from_edges_ex(edge_list, directed=False):
'''
pydot_ng.graph_from_edges()のノード識別子への対応版
graph_from_edges()のedge_listで指定するタプルは
識別子とグラフ表示時のラベルが同一のため、
ラベルが同じだが実体が異なるノードを表現することができない。
例えば文の係り受けをグラフにする際、文の中に同じ単語が
複数出てくると、それらのノードが同一視されて接続されてしまう。
この関数ではedge_listとして次の書式のタプルを受け取り、
ラベルが同一でも識別子が異なるノードは別ものとして扱う。
edge_list = [((識別子1,ラベル1),(識別子2,ラベル2)), ...]
識別子はノードを識別するためのもので表示されない。
ラベルは表示用で、同じでも識別子が異なれば別のノードになる。
なお、オリジナルの関数にあるnode_prefixは未実装。
戻り値：
pydot.Dotオブジェクト
'''
if directed:
graph = pydot.Dot(graph_type='digraph')
else:
graph = pydot.Dot(graph_type='graph')
for edge in edge_list:
id1 = str(edge[0][0])
label1 = str(edge[0][1])
id2 = str(edge[1][0])
label2 = str(edge[1][1])
# ノード追加
graph.add_node(pydot.Node(id1, label=label1))
graph.add_node(pydot.Node(id2, label=label2))
# エッジ追加
graph.add_edge(pydot.Edge(id1, id2))
return graph
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(pydot.Node(name, label=name))
self.assertEqual(set([n.get_name() for n in
self.graph_directed.get_nodes()]), names)
def add_outputs(dot, model, max_outputs):
# add outputs
for node_name, output_node in model['outputs'].items():
source = output_node['node_index']
if len(output_node['labels']) > max_outputs:
lab = node_name
num = len(output_node['labels'])
out_name = f'out_{source}_{lab}'
dot.add_node(pydot.Node(out_name, label=lab + f'({num})'))
dot.add_edge(pydot.Edge(str(source), out_name))
else:
for lab in output_node['labels']:
out_name = f'out_{source}_{lab}'
dot.add_node(pydot.Node(out_name, label=lab))
dot.add_edge(pydot.Edge(str(source), out_name))
return dot
def make_graph(edges: list):
graph = pydot.Dot(graph_type='digraph')
for edge in edges:
id1 = edge[0][0]
label1 = edge[0][1]
id2 = edge[1][0]
label2 = edge[1][1]
# print('{} {} {} {}\n'.format(id1, label1, id2, label2))
# ノードの追加
graph.add_node(pydot.Node(id1, label=label1))
graph.add_node(pydot.Node(id2, label=label2))
# 上で追加したノードをつなぐエッジを追加、idで判断
graph.add_edge(pydot.Edge(id1, id2))
return graph
def test_create_simple_graph_with_node(self):
g = pydot.Dot()
g.set_type('digraph')
node = pydot.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')
def visualization(sentence):
# 一応有向グラフも作る
graph = pydot.Dot(graph_type='digraph')
for source_chunk in sentence:
s = pattern.sub("", source_chunk.morphstr)
if "名詞" in [x.pos for x in source_chunk.morphs]:
source_idx = source_chunk.index
dst = source_chunk.dst
# 名詞から最後まで辿る
while dst != -1:
s += " -> {}".format(pattern.sub("", sentence[dst].morphstr))
graph.add_node(pydot.Node(source_idx,
label=pattern.sub("", sentence[source_idx].morphstr)))
graph.add_node(pydot.Node(dst,
label=pattern.sub("", sentence[dst].morphstr)))
graph.add_edge(pydot.Edge(source_idx, dst))
source_idx = dst
dst = sentence[dst].dst
print(s)
graph.write_png('knock48.png')
def test_graph_pickling(self):
import pickle
g = pydot.Graph()
s = pydot.Subgraph("foo")
g.add_subgraph(s)
g.add_edge(pydot.Edge('A', 'B'))
g.add_edge(pydot.Edge('A', 'C'))
g.add_edge(pydot.Edge(('D', 'E')))
g.add_node(pydot.Node('node!'))
self.assertEqual(type(pickle.dumps(g)), bytes)
