564 lines
24 KiB
Python
564 lines
24 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Natural Language Toolkit: ASCII visualization of NLTK trees
|
|
#
|
|
# Copyright (C) 2001-2018 NLTK Project
|
|
# Author: Andreas van Cranenburgh <A.W.vanCranenburgh@uva.nl>
|
|
# Peter Ljunglöf <peter.ljunglof@gu.se>
|
|
# URL: <http://nltk.org/>
|
|
# For license information, see LICENSE.TXT
|
|
|
|
"""
|
|
Pretty-printing of discontinuous trees.
|
|
Adapted from the disco-dop project, by Andreas van Cranenburgh.
|
|
https://github.com/andreasvc/disco-dop
|
|
|
|
Interesting reference (not used for this code):
|
|
T. Eschbach et al., Orth. Hypergraph Drawing, Journal of
|
|
Graph Algorithms and Applications, 10(2) 141--157 (2006)149.
|
|
http://jgaa.info/accepted/2006/EschbachGuentherBecker2006.10.2.pdf
|
|
"""
|
|
|
|
from __future__ import division, print_function, unicode_literals
|
|
|
|
from nltk.util import slice_bounds, OrderedDict
|
|
from nltk.compat import python_2_unicode_compatible, unicode_repr
|
|
from nltk.internals import raise_unorderable_types
|
|
from nltk.tree import Tree
|
|
|
|
import re
|
|
import sys
|
|
import codecs
|
|
from cgi import escape
|
|
from collections import defaultdict
|
|
from operator import itemgetter
|
|
from itertools import chain, islice
|
|
|
|
|
|
ANSICOLOR = {
|
|
'black': 30,
|
|
'red': 31,
|
|
'green': 32,
|
|
'yellow': 33,
|
|
'blue': 34,
|
|
'magenta': 35,
|
|
'cyan': 36,
|
|
'white': 37,
|
|
}
|
|
|
|
|
|
@python_2_unicode_compatible
|
|
class TreePrettyPrinter(object):
|
|
"""
|
|
Pretty-print a tree in text format, either as ASCII or Unicode.
|
|
The tree can be a normal tree, or discontinuous.
|
|
|
|
``TreePrettyPrinter(tree, sentence=None, highlight=())``
|
|
creates an object from which different visualizations can be created.
|
|
|
|
:param tree: a Tree object.
|
|
:param sentence: a list of words (strings). If `sentence` is given,
|
|
`tree` must contain integers as leaves, which are taken as indices
|
|
in `sentence`. Using this you can display a discontinuous tree.
|
|
:param highlight: Optionally, a sequence of Tree objects in `tree` which
|
|
should be highlighted. Has the effect of only applying colors to nodes
|
|
in this sequence (nodes should be given as Tree objects, terminals as
|
|
indices).
|
|
|
|
>>> from nltk.tree import Tree
|
|
>>> tree = Tree.fromstring('(S (NP Mary) (VP walks))')
|
|
>>> print(TreePrettyPrinter(tree).text())
|
|
... # doctest: +NORMALIZE_WHITESPACE
|
|
S
|
|
____|____
|
|
NP VP
|
|
| |
|
|
Mary walks
|
|
"""
|
|
|
|
def __init__(self, tree, sentence=None, highlight=()):
|
|
if sentence is None:
|
|
leaves = tree.leaves()
|
|
if (leaves and not any(len(a) == 0 for a in tree.subtrees())
|
|
and all(isinstance(a, int) for a in leaves)):
|
|
sentence = [str(a) for a in leaves]
|
|
else:
|
|
# this deals with empty nodes (frontier non-terminals)
|
|
# and multiple/mixed terminals under non-terminals.
|
|
tree = tree.copy(True)
|
|
sentence = []
|
|
for a in tree.subtrees():
|
|
if len(a) == 0:
|
|
a.append(len(sentence))
|
|
sentence.append(None)
|
|
elif any(not isinstance(b, Tree) for b in a):
|
|
for n, b in enumerate(a):
|
|
if not isinstance(b, Tree):
|
|
a[n] = len(sentence)
|
|
sentence.append('%s' % b)
|
|
self.nodes, self.coords, self.edges, self.highlight = self.nodecoords(
|
|
tree, sentence, highlight)
|
|
|
|
def __str__(self):
|
|
return self.text()
|
|
|
|
def __repr__(self):
|
|
return '<TreePrettyPrinter with %d nodes>' % len(self.nodes)
|
|
|
|
|
|
@staticmethod
|
|
def nodecoords(tree, sentence, highlight):
|
|
"""
|
|
Produce coordinates of nodes on a grid.
|
|
|
|
Objective:
|
|
|
|
- Produce coordinates for a non-overlapping placement of nodes and
|
|
horizontal lines.
|
|
- Order edges so that crossing edges cross a minimal number of previous
|
|
horizontal lines (never vertical lines).
|
|
|
|
Approach:
|
|
|
|
- bottom up level order traversal (start at terminals)
|
|
- at each level, identify nodes which cannot be on the same row
|
|
- identify nodes which cannot be in the same column
|
|
- place nodes into a grid at (row, column)
|
|
- order child-parent edges with crossing edges last
|
|
|
|
Coordinates are (row, column); the origin (0, 0) is at the top left;
|
|
the root node is on row 0. Coordinates do not consider the size of a
|
|
node (which depends on font, &c), so the width of a column of the grid
|
|
should be automatically determined by the element with the greatest
|
|
width in that column. Alternatively, the integer coordinates could be
|
|
converted to coordinates in which the distances between adjacent nodes
|
|
are non-uniform.
|
|
|
|
Produces tuple (nodes, coords, edges, highlighted) where:
|
|
|
|
- nodes[id]: Tree object for the node with this integer id
|
|
- coords[id]: (n, m) coordinate where to draw node with id in the grid
|
|
- edges[id]: parent id of node with this id (ordered dictionary)
|
|
- highlighted: set of ids that should be highlighted
|
|
"""
|
|
def findcell(m, matrix, startoflevel, children):
|
|
"""
|
|
Find vacant row, column index for node ``m``.
|
|
Iterate over current rows for this level (try lowest first)
|
|
and look for cell between first and last child of this node,
|
|
add new row to level if no free row available.
|
|
"""
|
|
candidates = [a for _, a in children[m]]
|
|
minidx, maxidx = min(candidates), max(candidates)
|
|
leaves = tree[m].leaves()
|
|
center = scale * sum(leaves) // len(leaves) # center of gravity
|
|
if minidx < maxidx and not minidx < center < maxidx:
|
|
center = sum(candidates) // len(candidates)
|
|
if max(candidates) - min(candidates) > 2 * scale:
|
|
center -= center % scale # round to unscaled coordinate
|
|
if minidx < maxidx and not minidx < center < maxidx:
|
|
center += scale
|
|
if ids[m] == 0:
|
|
startoflevel = len(matrix)
|
|
for rowidx in range(startoflevel, len(matrix) + 1):
|
|
if rowidx == len(matrix): # need to add a new row
|
|
matrix.append([vertline if a not in (corner, None)
|
|
else None for a in matrix[-1]])
|
|
row = matrix[rowidx]
|
|
i = j = center
|
|
if len(children[m]) == 1: # place unaries directly above child
|
|
return rowidx, next(iter(children[m]))[1]
|
|
elif all(a is None or a == vertline for a
|
|
in row[min(candidates):max(candidates) + 1]):
|
|
# find free column
|
|
for n in range(scale):
|
|
i = j = center + n
|
|
while j > minidx or i < maxidx:
|
|
if i < maxidx and (matrix[rowidx][i] is None
|
|
or i in candidates):
|
|
return rowidx, i
|
|
elif j > minidx and (matrix[rowidx][j] is None
|
|
or j in candidates):
|
|
return rowidx, j
|
|
i += scale
|
|
j -= scale
|
|
raise ValueError('could not find a free cell for:\n%s\n%s'
|
|
'min=%d; max=%d' % (tree[m], minidx, maxidx, dumpmatrix()))
|
|
|
|
def dumpmatrix():
|
|
"""Dump matrix contents for debugging purposes."""
|
|
return '\n'.join(
|
|
'%2d: %s' % (n, ' '.join(('%2r' % i)[:2] for i in row))
|
|
for n, row in enumerate(matrix))
|
|
|
|
leaves = tree.leaves()
|
|
if not all(isinstance(n, int) for n in leaves):
|
|
raise ValueError('All leaves must be integer indices.')
|
|
if len(leaves) != len(set(leaves)):
|
|
raise ValueError('Indices must occur at most once.')
|
|
if not all(0 <= n < len(sentence) for n in leaves):
|
|
raise ValueError('All leaves must be in the interval 0..n '
|
|
'with n=len(sentence)\ntokens: %d indices: '
|
|
'%r\nsentence: %s' % (len(sentence), tree.leaves(), sentence))
|
|
vertline, corner = -1, -2 # constants
|
|
tree = tree.copy(True)
|
|
for a in tree.subtrees():
|
|
a.sort(key=lambda n: min(n.leaves()) if isinstance(n, Tree) else n)
|
|
scale = 2
|
|
crossed = set()
|
|
# internal nodes and lexical nodes (no frontiers)
|
|
positions = tree.treepositions()
|
|
maxdepth = max(map(len, positions)) + 1
|
|
childcols = defaultdict(set)
|
|
matrix = [[None] * (len(sentence) * scale)]
|
|
nodes = {}
|
|
ids = dict((a, n) for n, a in enumerate(positions))
|
|
highlighted_nodes = set(n for a, n in ids.items()
|
|
if not highlight or tree[a] in highlight)
|
|
levels = dict((n, []) for n in range(maxdepth - 1))
|
|
terminals = []
|
|
for a in positions:
|
|
node = tree[a]
|
|
if isinstance(node, Tree):
|
|
levels[maxdepth - node.height()].append(a)
|
|
else:
|
|
terminals.append(a)
|
|
|
|
for n in levels:
|
|
levels[n].sort(key=lambda n: max(tree[n].leaves())
|
|
- min(tree[n].leaves()))
|
|
terminals.sort()
|
|
positions = set(positions)
|
|
|
|
for m in terminals:
|
|
i = int(tree[m]) * scale
|
|
assert matrix[0][i] is None, (matrix[0][i], m, i)
|
|
matrix[0][i] = ids[m]
|
|
nodes[ids[m]] = sentence[tree[m]]
|
|
if nodes[ids[m]] is None:
|
|
nodes[ids[m]] = '...'
|
|
highlighted_nodes.discard(ids[m])
|
|
positions.remove(m)
|
|
childcols[m[:-1]].add((0, i))
|
|
|
|
# add other nodes centered on their children,
|
|
# if the center is already taken, back off
|
|
# to the left and right alternately, until an empty cell is found.
|
|
for n in sorted(levels, reverse=True):
|
|
nodesatdepth = levels[n]
|
|
startoflevel = len(matrix)
|
|
matrix.append([vertline if a not in (corner, None) else None
|
|
for a in matrix[-1]])
|
|
for m in nodesatdepth: # [::-1]:
|
|
if n < maxdepth - 1 and childcols[m]:
|
|
_, pivot = min(childcols[m], key=itemgetter(1))
|
|
if (set(a[:-1] for row in matrix[:-1] for a in row[:pivot]
|
|
if isinstance(a, tuple)) &
|
|
set(a[:-1] for row in matrix[:-1] for a in row[pivot:]
|
|
if isinstance(a, tuple))):
|
|
crossed.add(m)
|
|
|
|
rowidx, i = findcell(m, matrix, startoflevel, childcols)
|
|
positions.remove(m)
|
|
|
|
# block positions where children of this node branch out
|
|
for _, x in childcols[m]:
|
|
matrix[rowidx][x] = corner
|
|
# assert m == () or matrix[rowidx][i] in (None, corner), (
|
|
# matrix[rowidx][i], m, str(tree), ' '.join(sentence))
|
|
# node itself
|
|
matrix[rowidx][i] = ids[m]
|
|
nodes[ids[m]] = tree[m]
|
|
# add column to the set of children for its parent
|
|
if m != ():
|
|
childcols[m[:-1]].add((rowidx, i))
|
|
assert len(positions) == 0
|
|
|
|
# remove unused columns, right to left
|
|
for m in range(scale * len(sentence) - 1, -1, -1):
|
|
if not any(isinstance(row[m], (Tree, int))
|
|
for row in matrix):
|
|
for row in matrix:
|
|
del row[m]
|
|
|
|
# remove unused rows, reverse
|
|
matrix = [row for row in reversed(matrix)
|
|
if not all(a is None or a == vertline for a in row)]
|
|
|
|
# collect coordinates of nodes
|
|
coords = {}
|
|
for n, _ in enumerate(matrix):
|
|
for m, i in enumerate(matrix[n]):
|
|
if isinstance(i, int) and i >= 0:
|
|
coords[i] = n, m
|
|
|
|
# move crossed edges last
|
|
positions = sorted([a for level in levels.values()
|
|
for a in level], key=lambda a: a[:-1] in crossed)
|
|
|
|
# collect edges from node to node
|
|
edges = OrderedDict()
|
|
for i in reversed(positions):
|
|
for j, _ in enumerate(tree[i]):
|
|
edges[ids[i + (j, )]] = ids[i]
|
|
|
|
return nodes, coords, edges, highlighted_nodes
|
|
|
|
|
|
def text(self, nodedist=1, unicodelines=False, html=False, ansi=False,
|
|
nodecolor='blue', leafcolor='red', funccolor='green',
|
|
abbreviate=None, maxwidth=16):
|
|
"""
|
|
:return: ASCII art for a discontinuous tree.
|
|
|
|
:param unicodelines: whether to use Unicode line drawing characters
|
|
instead of plain (7-bit) ASCII.
|
|
:param html: whether to wrap output in html code (default plain text).
|
|
:param ansi: whether to produce colors with ANSI escape sequences
|
|
(only effective when html==False).
|
|
:param leafcolor, nodecolor: specify colors of leaves and phrasal
|
|
nodes; effective when either html or ansi is True.
|
|
:param abbreviate: if True, abbreviate labels longer than 5 characters.
|
|
If integer, abbreviate labels longer than `abbr` characters.
|
|
:param maxwidth: maximum number of characters before a label starts to
|
|
wrap; pass None to disable.
|
|
"""
|
|
if abbreviate == True:
|
|
abbreviate = 5
|
|
if unicodelines:
|
|
horzline = '\u2500'
|
|
leftcorner = '\u250c'
|
|
rightcorner = '\u2510'
|
|
vertline = ' \u2502 '
|
|
tee = horzline + '\u252C' + horzline
|
|
bottom = horzline + '\u2534' + horzline
|
|
cross = horzline + '\u253c' + horzline
|
|
ellipsis = '\u2026'
|
|
else:
|
|
horzline = '_'
|
|
leftcorner = rightcorner = ' '
|
|
vertline = ' | '
|
|
tee = 3 * horzline
|
|
cross = bottom = '_|_'
|
|
ellipsis = '.'
|
|
|
|
def crosscell(cur, x=vertline):
|
|
"""Overwrite center of this cell with a vertical branch."""
|
|
splitl = len(cur) - len(cur) // 2 - len(x) // 2 - 1
|
|
lst = list(cur)
|
|
lst[splitl:splitl + len(x)] = list(x)
|
|
return ''.join(lst)
|
|
|
|
result = []
|
|
matrix = defaultdict(dict)
|
|
maxnodewith = defaultdict(lambda: 3)
|
|
maxnodeheight = defaultdict(lambda: 1)
|
|
maxcol = 0
|
|
minchildcol = {}
|
|
maxchildcol = {}
|
|
childcols = defaultdict(set)
|
|
labels = {}
|
|
wrapre = re.compile('(.{%d,%d}\\b\\W*|.{%d})' % (
|
|
maxwidth - 4, maxwidth, maxwidth))
|
|
# collect labels and coordinates
|
|
for a in self.nodes:
|
|
row, column = self.coords[a]
|
|
matrix[row][column] = a
|
|
maxcol = max(maxcol, column)
|
|
label = (self.nodes[a].label() if isinstance(self.nodes[a], Tree)
|
|
else self.nodes[a])
|
|
if abbreviate and len(label) > abbreviate:
|
|
label = label[:abbreviate] + ellipsis
|
|
if maxwidth and len(label) > maxwidth:
|
|
label = wrapre.sub(r'\1\n', label).strip()
|
|
label = label.split('\n')
|
|
maxnodeheight[row] = max(maxnodeheight[row], len(label))
|
|
maxnodewith[column] = max(maxnodewith[column], max(map(len, label)))
|
|
labels[a] = label
|
|
if a not in self.edges:
|
|
continue # e.g., root
|
|
parent = self.edges[a]
|
|
childcols[parent].add((row, column))
|
|
minchildcol[parent] = min(minchildcol.get(parent, column), column)
|
|
maxchildcol[parent] = max(maxchildcol.get(parent, column), column)
|
|
# bottom up level order traversal
|
|
for row in sorted(matrix, reverse=True):
|
|
noderows = [[''.center(maxnodewith[col]) for col in range(maxcol + 1)]
|
|
for _ in range(maxnodeheight[row])]
|
|
branchrow = [''.center(maxnodewith[col]) for col in range(maxcol + 1)]
|
|
for col in matrix[row]:
|
|
n = matrix[row][col]
|
|
node = self.nodes[n]
|
|
text = labels[n]
|
|
if isinstance(node, Tree):
|
|
# draw horizontal branch towards children for this node
|
|
if n in minchildcol and minchildcol[n] < maxchildcol[n]:
|
|
i, j = minchildcol[n], maxchildcol[n]
|
|
a, b = (maxnodewith[i] + 1) // 2 - 1, maxnodewith[j] // 2
|
|
branchrow[i] = ((' ' * a) + leftcorner).ljust(
|
|
maxnodewith[i], horzline)
|
|
branchrow[j] = (rightcorner + (' ' * b)).rjust(
|
|
maxnodewith[j], horzline)
|
|
for i in range(minchildcol[n] + 1, maxchildcol[n]):
|
|
if i == col and any(
|
|
a == i for _, a in childcols[n]):
|
|
line = cross
|
|
elif i == col:
|
|
line = bottom
|
|
elif any(a == i for _, a in childcols[n]):
|
|
line = tee
|
|
else:
|
|
line = horzline
|
|
branchrow[i] = line.center(maxnodewith[i], horzline)
|
|
else: # if n and n in minchildcol:
|
|
branchrow[col] = crosscell(branchrow[col])
|
|
text = [a.center(maxnodewith[col]) for a in text]
|
|
color = nodecolor if isinstance(node, Tree) else leafcolor
|
|
if isinstance(node, Tree) and node.label().startswith('-'):
|
|
color = funccolor
|
|
if html:
|
|
text = [escape(a) for a in text]
|
|
if n in self.highlight:
|
|
text = ['<font color=%s>%s</font>' % (
|
|
color, a) for a in text]
|
|
elif ansi and n in self.highlight:
|
|
text = ['\x1b[%d;1m%s\x1b[0m' % (
|
|
ANSICOLOR[color], a) for a in text]
|
|
for x in range(maxnodeheight[row]):
|
|
# draw vertical lines in partially filled multiline node
|
|
# labels, but only if it's not a frontier node.
|
|
noderows[x][col] = (text[x] if x < len(text)
|
|
else (vertline if childcols[n] else ' ').center(
|
|
maxnodewith[col], ' '))
|
|
# for each column, if there is a node below us which has a parent
|
|
# above us, draw a vertical branch in that column.
|
|
if row != max(matrix):
|
|
for n, (childrow, col) in self.coords.items():
|
|
if (n > 0 and
|
|
self.coords[self.edges[n]][0] < row < childrow):
|
|
branchrow[col] = crosscell(branchrow[col])
|
|
if col not in matrix[row]:
|
|
for noderow in noderows:
|
|
noderow[col] = crosscell(noderow[col])
|
|
branchrow = [a + ((a[-1] if a[-1] != ' ' else b[0]) * nodedist)
|
|
for a, b in zip(branchrow, branchrow[1:] + [' '])]
|
|
result.append(''.join(branchrow))
|
|
result.extend((' ' * nodedist).join(noderow)
|
|
for noderow in reversed(noderows))
|
|
return '\n'.join(reversed(result)) + '\n'
|
|
|
|
|
|
def svg(self, nodecolor='blue', leafcolor='red', funccolor='green'):
|
|
"""
|
|
:return: SVG representation of a tree.
|
|
"""
|
|
fontsize = 12
|
|
hscale = 40
|
|
vscale = 25
|
|
hstart = vstart = 20
|
|
width = max(col for _, col in self.coords.values())
|
|
height = max(row for row, _ in self.coords.values())
|
|
result = ['<svg version="1.1" xmlns="http://www.w3.org/2000/svg" '
|
|
'width="%dem" height="%dem" viewBox="%d %d %d %d">' % (
|
|
width * 3,
|
|
height * 2.5,
|
|
-hstart, -vstart,
|
|
width * hscale + 3 * hstart,
|
|
height * vscale + 3 * vstart)
|
|
]
|
|
|
|
children = defaultdict(set)
|
|
for n in self.nodes:
|
|
if n:
|
|
children[self.edges[n]].add(n)
|
|
|
|
# horizontal branches from nodes to children
|
|
for node in self.nodes:
|
|
if not children[node]:
|
|
continue
|
|
y, x = self.coords[node]
|
|
x *= hscale
|
|
y *= vscale
|
|
x += hstart
|
|
y += vstart + fontsize // 2
|
|
childx = [self.coords[c][1] for c in children[node]]
|
|
xmin = hstart + hscale * min(childx)
|
|
xmax = hstart + hscale * max(childx)
|
|
result.append(
|
|
'\t<polyline style="stroke:black; stroke-width:1; fill:none;" '
|
|
'points="%g,%g %g,%g" />' % (xmin, y, xmax, y))
|
|
result.append(
|
|
'\t<polyline style="stroke:black; stroke-width:1; fill:none;" '
|
|
'points="%g,%g %g,%g" />' % (x, y, x, y - fontsize // 3))
|
|
|
|
# vertical branches from children to parents
|
|
for child, parent in self.edges.items():
|
|
y, _ = self.coords[parent]
|
|
y *= vscale
|
|
y += vstart + fontsize // 2
|
|
childy, childx = self.coords[child]
|
|
childx *= hscale
|
|
childy *= vscale
|
|
childx += hstart
|
|
childy += vstart - fontsize
|
|
result += [
|
|
'\t<polyline style="stroke:white; stroke-width:10; fill:none;"'
|
|
' points="%g,%g %g,%g" />' % (childx, childy, childx, y + 5),
|
|
'\t<polyline style="stroke:black; stroke-width:1; fill:none;"'
|
|
' points="%g,%g %g,%g" />' % (childx, childy, childx, y),
|
|
]
|
|
|
|
# write nodes with coordinates
|
|
for n, (row, column) in self.coords.items():
|
|
node = self.nodes[n]
|
|
x = column * hscale + hstart
|
|
y = row * vscale + vstart
|
|
if n in self.highlight:
|
|
color = nodecolor if isinstance(node, Tree) else leafcolor
|
|
if isinstance(node, Tree) and node.label().startswith('-'):
|
|
color = funccolor
|
|
else:
|
|
color = 'black'
|
|
result += ['\t<text style="text-anchor: middle; fill: %s; '
|
|
'font-size: %dpx;" x="%g" y="%g">%s</text>' % (
|
|
color, fontsize, x, y,
|
|
escape(node.label() if isinstance(node, Tree)
|
|
else node))]
|
|
|
|
result += ['</svg>']
|
|
return '\n'.join(result)
|
|
|
|
|
|
def test():
|
|
"""Do some tree drawing tests."""
|
|
def print_tree(n, tree, sentence=None, ansi=True, **xargs):
|
|
print()
|
|
print('{0}: "{1}"'.format(n, ' '.join(sentence or tree.leaves())))
|
|
print(tree)
|
|
print()
|
|
drawtree = TreePrettyPrinter(tree, sentence)
|
|
try:
|
|
print(drawtree.text(unicodelines=ansi, ansi=ansi, **xargs))
|
|
except (UnicodeDecodeError, UnicodeEncodeError):
|
|
print(drawtree.text(unicodelines=False, ansi=False, **xargs))
|
|
|
|
from nltk.corpus import treebank
|
|
for n in [0, 1440, 1591, 2771, 2170]:
|
|
tree = treebank.parsed_sents()[n]
|
|
print_tree(n, tree, nodedist=2, maxwidth=8)
|
|
print()
|
|
print('ASCII version:')
|
|
print(TreePrettyPrinter(tree).text(nodedist=2))
|
|
|
|
tree = Tree.fromstring(
|
|
'(top (punct 8) (smain (noun 0) (verb 1) (inf (verb 5) (inf (verb 6) '
|
|
'(conj (inf (pp (prep 2) (np (det 3) (noun 4))) (verb 7)) (inf (verb 9)) '
|
|
'(vg 10) (inf (verb 11)))))) (punct 12))', read_leaf=int)
|
|
sentence = ('Ze had met haar moeder kunnen gaan winkelen ,'
|
|
' zwemmen of terrassen .'.split())
|
|
print_tree('Discontinuous tree', tree, sentence, nodedist=2)
|
|
|
|
|
|
__all__ = ['TreePrettyPrinter']
|
|
|
|
if __name__ == '__main__':
|
|
test()
|