def to_dot_str_graph(self):
lines = [u'digraph finite_state_machine {', '\tdpi=100;']
node_lines = []
for node in self.G.nodes():
d_node = Machine.d_clean(node)
d_node_id = d_node.replace('=', '_')
if "_" in d_node_id:
d_node = d_node_id.split('_')[-2]
else:
d_node= d_node_id
node_lines.append(u'\t{0} [shape = circle, label = "{1}"];'.format(
d_node_id, d_node).replace('-', '_'))
lines += sorted(node_lines)
edge_lines = []
for u,v, edata in self.G.edges(data=True):
d_u = Machine.d_clean(u)
d_v = Machine.d_clean(v)
d_u = d_u.replace('=', '_')
d_v = d_v.replace('=', '_')
edge_lines.append(
u'\t{0} -> {1} [ label = "{2}" ];'.format(
d_u, d_v,edata['color']))
lines += sorted(edge_lines)
lines.append('}')
return u'\n'.join(lines)
def to_dot_str_graph(self):
lines = [u'digraph finite_state_machine {', '\tdpi=100;']
node_lines = []
for node in self.G.nodes():
d_node = Machine.d_clean(node)
d_node_id = d_node.replace('=', '_')
if "_" in d_node_id:
d_node = d_node_id.split('_')[-2]
else:
d_node = d_node_id
node_lines.append(u'\t{0} [shape = circle, label = "{1}"];'.format(
d_node_id, d_node).replace('-', '_'))
lines += sorted(node_lines)
edge_lines = []
for u, v, edata in self.G.edges(data=True):
d_u = Machine.d_clean(u)
d_v = Machine.d_clean(v)
d_u = d_u.replace('=', '_')
d_v = d_v.replace('=', '_')
edge_lines.append(u'\t{0} -> {1} [ label = "{2}" ];'.format(
d_u, d_v, edata['color']))
lines += sorted(edge_lines)
lines.append('}')
return u'\n'.join(lines)
def draw_single_graph(self, word, path):
clean_word = Machine.d_clean(word)
for c, machine in enumerate(self.definitions[word]):
graph = MachineGraph.create_from_machines([machine])
file_name = os.path.join(path, '{0}_{1}.dot'.format(clean_word, c))
with open(file_name, 'w') as file_obj:
file_obj.write(graph.to_dot().encode('utf-8'))
def draw_single_graph(self, word, path):
clean_word = Machine.d_clean(word)
for c, machine in enumerate(self.definitions[word]):
graph = MachineGraph.create_from_machines([machine])
file_name = os.path.join(path, '{0}_{1}.dot'.format(clean_word, c))
with open(file_name, 'w') as file_obj:
file_obj.write(graph.to_dot().encode('utf-8'))
def draw_word_graphs(self):
ensure_dir('graphs/words')
for c, (word, machines) in enumerate(self.definitions.iteritems()):
if c % 1000 == 0:
logging.info("{0}...".format(c))
for i, machine in enumerate(machines):
graph = MachineGraph.create_from_machines([machine])
clean_word = Machine.d_clean(word)
if clean_word[0] == 'X':
clean_word = clean_word[1:]
f = open('graphs/words/{0}_{1}.dot'.format(clean_word, i), 'w')
f.write(graph.to_dot().encode('utf-8'))
def draw_word_graphs(self):
ensure_dir('graphs/words')
for c, (word, machines) in enumerate(self.definitions.iteritems()):
if c % 1000 == 0:
logging.info("{0}...".format(c))
for i, machine in enumerate(machines):
graph = MachineGraph.create_from_machines([machine])
clean_word = Machine.d_clean(word)
if clean_word[0] == 'X':
clean_word = clean_word[1:]
f = open('graphs/words/{0}_{1}.dot'.format(clean_word, i), 'w')
f.write(graph.to_dot().encode('utf-8'))
def to_dot(self):
lines = [u'digraph finite_state_machine {', '\tdpi=100;']
# lines.append('\tordering=out;')
# sorting everything to make the process deterministic
node_lines = []
for node, n_data in self.G.nodes(data=True):
d_node = Machine.d_clean(node)
printname = Machine.d_clean('_'.join(d_node.split('_')[:-1]))
if 'expanded' in n_data and not n_data['expanded']:
node_line = u'\t{0} [shape = circle, label = "{1}", style="filled"];'.format( # nopep8
d_node, printname).replace('-', '_')
else:
node_line = u'\t{0} [shape = circle, label = "{1}"];'.format(
d_node, printname).replace('-', '_')
node_lines.append(node_line)
lines += sorted(node_lines)
edge_lines = []
for u,v,edata in self.G.edges(data=True):
if 'color' in edata:
d_node1 = Machine.d_clean(u)
d_node2 = Machine.d_clean(v)
edge_lines.append(
u'\t{0} -> {1} [ label = "{2}" ];'.format(
Machine.d_clean(d_node1), Machine.d_clean(d_node2),edata['color']))
lines += sorted(edge_lines)
lines.append('}')
return u'\n'.join(lines)
def to_dot(self):
lines = [u'digraph finite_state_machine {', '\tdpi=100;']
# lines.append('\tordering=out;')
# sorting everything to make the process deterministic
node_lines = []
for node, n_data in self.G.nodes(data=True):
d_node = Machine.d_clean(node)
printname = Machine.d_clean('_'.join(d_node.split('_')[:-1]))
if 'expanded' in n_data and not n_data['expanded']:
node_line = u'\t{0} [shape = circle, label = "{1}", style="filled"];'.format( # nopep8
d_node, printname).replace('-', '_')
else:
node_line = u'\t{0} [shape = circle, label = "{1}"];'.format(
d_node, printname).replace('-', '_')
node_lines.append(node_line)
lines += sorted(node_lines)
edge_lines = []
for u, v, edata in self.G.edges(data=True):
if 'color' in edata:
d_node1 = Machine.d_clean(u)
d_node2 = Machine.d_clean(v)
edge_lines.append(u'\t{0} -> {1} [ label = "{2}" ];'.format(
Machine.d_clean(d_node1), Machine.d_clean(d_node2),
edata['color']))
lines += sorted(edge_lines)
lines.append('}')
return u'\n'.join(lines)
def to_dot(self):
lines = [u'digraph finite_state_machine {', '\tdpi=100;']
# lines.append('\tordering=out;')
# sorting everything to make the process deterministic
node_lines = []
for node in self.G.nodes_iter():
d_node = Machine.d_clean(node)
printname = Machine.d_clean(d_node.split('_')[0])
node_lines.append(u'\t{0} [shape = circle, label = "{1}"];'.format(
d_node, printname).replace('-', '_'))
lines += sorted(node_lines)
edge_lines = []
for node1, adjacency in self.G.adjacency_iter():
d_node1 = Machine.d_clean(node1)
for node2, edges in adjacency.iteritems():
d_node2 = Machine.d_clean(node2)
for i, attributes in edges.iteritems():
edge_lines.append(
u'\t{0} -> {1} [ label = "{2}" ];'.format(
d_node1.replace('-', '_'),
d_node2.replace('-', '_'), attributes['color']))
lines += sorted(edge_lines)
lines.append('}')
return u'\n'.join(lines)
def dep_to_dot(deps, fn):
try:
edges = [(d['dep']['lemma'], d['type'], d['gov']['lemma'])
for d in deps if d['type'] not in EXCLUDE]
except:
edges = [(d[1][0], d[0], d[2][0]) for d in deps if d[0] not in EXCLUDE]
words = set([e[0] for e in edges] + [e[2] for e in edges])
lines = []
for word in words:
lines.append(u'\t{0} [shape=rectangle, label="{0}"];'.format(
Machine.d_clean(word)))
for edge in edges:
dep, dtype, gov = map(Machine.d_clean, edge)
lines.append(u'\t{0} -> {1} [label="{2}"];'.format(dep, gov, dtype))
with open(fn, 'w') as f:
f.write(HEADER.encode("utf-8"))
f.write(u"\n".join(lines).encode("utf-8"))
f.write("}\n")
def dep_to_dot(deps, fn):
try:
edges = [
(d['dep']['lemma'], d['type'], d['gov']['lemma']) for d in deps
if d['type'] not in EXCLUDE]
except:
edges = [(d[1][0], d[0], d[2][0]) for d in deps if d[0] not in EXCLUDE]
words = set([e[0] for e in edges] + [e[2] for e in edges])
lines = []
for word in words:
lines.append(u'\t{0} [shape=rectangle, label="{0}"];'.format(
Machine.d_clean(word)))
for edge in edges:
dep, dtype, gov = map(Machine.d_clean, edge)
lines.append(u'\t{0} -> {1} [label="{2}"];'.format(dep, gov, dtype))
with open(fn, 'w') as f:
f.write(HEADER.encode("utf-8"))
f.write(u"\n".join(lines).encode("utf-8"))
f.write("}\n")
def dep_to_dot(deps):
if isinstance(deps[0], dict):
# new dep structure
edges = [(d['dep']['lemma'], d['type'], d['gov']['lemma'])
for d in deps if d['type'] not in EXCLUDE]
else:
# old dep structure
edges = [(d[1][0], d[0], d[2][0]) for d in deps if d[0] not in EXCLUDE]
words = set([e[0] for e in edges] + [e[2] for e in edges])
lines = []
for word in words:
lines.append(u'\t{0} [shape=rectangle, label="{0}"];'.format(
Machine.d_clean(word)))
for edge in edges:
dep, dtype, gov = map(Machine.d_clean, edge)
lines.append(u'\t{0} -> {1} [label="{2}"];'.format(dep, gov, dtype))
dot_str = HEADER.encode("utf-8")
dot_str += u"\n".join(lines).encode("utf-8")
dot_str += "}\n"
return dot_str
def dep_to_dot(deps):
if isinstance(deps[0], dict):
# new dep structure
edges = [
(d['dep']['lemma'], d['type'], d['gov']['lemma']) for d in deps
if d['type'] not in EXCLUDE]
else:
# old dep structure
edges = [(d[1][0], d[0], d[2][0]) for d in deps if d[0] not in EXCLUDE]
words = set([e[0] for e in edges] + [e[2] for e in edges])
lines = []
for word in words:
lines.append(u'\t{0} [shape=rectangle, label="{0}"];'.format(
Machine.d_clean(word)))
for edge in edges:
dep, dtype, gov = map(Machine.d_clean, edge)
lines.append(u'\t{0} -> {1} [label="{2}"];'.format(dep, gov, dtype))
dot_str = HEADER.encode("utf-8")
dot_str += u"\n".join(lines).encode("utf-8")
dot_str += "}\n"
return dot_str
