2277 lines
84 KiB
Python
2277 lines
84 KiB
Python
|
# Natural Language Toolkit: Chart Parser Application
|
||
|
|
#
|
||
|
|
# Copyright (C) 2001-2018 NLTK Project
|
||
|
|
# Author: Edward Loper <edloper@gmail.com>
|
||
|
|
# Jean Mark Gawron <gawron@mail.sdsu.edu>
|
||
|
|
# Steven Bird <stevenbird1@gmail.com>
|
||
|
|
# URL: <http://nltk.org/>
|
||
|
|
# For license information, see LICENSE.TXT
|
||
|
|
|
||
|
|
"""
|
||
|
|
A graphical tool for exploring chart parsing.
|
||
|
|
|
||
|
|
Chart parsing is a flexible parsing algorithm that uses a data
|
||
|
|
structure called a "chart" to record hypotheses about syntactic
|
||
|
|
constituents. Each hypothesis is represented by a single "edge" on
|
||
|
|
the chart. A set of "chart rules" determine when new edges can be
|
||
|
|
added to the chart. This set of rules controls the overall behavior
|
||
|
|
of the parser (e.g. whether it parses top-down or bottom-up).
|
||
|
|
|
||
|
|
The chart parsing tool demonstrates the process of parsing a single
|
||
|
|
sentence, with a given grammar and lexicon. Its display is divided
|
||
|
|
into three sections: the bottom section displays the chart; the middle
|
||
|
|
section displays the sentence; and the top section displays the
|
||
|
|
partial syntax tree corresponding to the selected edge. Buttons along
|
||
|
|
the bottom of the window are used to control the execution of the
|
||
|
|
algorithm.
|
||
|
|
|
||
|
|
The chart parsing tool allows for flexible control of the parsing
|
||
|
|
algorithm. At each step of the algorithm, you can select which rule
|
||
|
|
or strategy you wish to apply. This allows you to experiment with
|
||
|
|
mixing different strategies (e.g. top-down and bottom-up). You can
|
||
|
|
exercise fine-grained control over the algorithm by selecting which
|
||
|
|
edge you wish to apply a rule to.
|
||
|
|
"""
|
||
|
|
|
||
|
|
# At some point, we should rewrite this tool to use the new canvas
|
||
|
|
# widget system.
|
||
|
|
|
||
|
|
|
||
|
|
from __future__ import division
|
||
|
|
import pickle
|
||
|
|
import os.path
|
||
|
|
|
||
|
|
from six.moves.tkinter import (Button, Canvas, Checkbutton, Frame, IntVar,
|
||
|
|
Label, Menu, Scrollbar, Tk, Toplevel)
|
||
|
|
from six.moves.tkinter_font import Font
|
||
|
|
from six.moves.tkinter_messagebox import showerror, showinfo
|
||
|
|
from six.moves.tkinter_tkfiledialog import asksaveasfilename, askopenfilename
|
||
|
|
|
||
|
|
from nltk.parse.chart import (BottomUpPredictCombineRule, BottomUpPredictRule,
|
||
|
|
Chart, LeafEdge, LeafInitRule, SingleEdgeFundamentalRule,
|
||
|
|
SteppingChartParser, TopDownInitRule, TopDownPredictRule,
|
||
|
|
TreeEdge)
|
||
|
|
from nltk.tree import Tree
|
||
|
|
from nltk.grammar import Nonterminal, CFG
|
||
|
|
from nltk.util import in_idle
|
||
|
|
from nltk.draw.util import (CanvasFrame, ColorizedList,
|
||
|
|
EntryDialog, MutableOptionMenu,
|
||
|
|
ShowText, SymbolWidget)
|
||
|
|
from nltk.draw import CFGEditor, tree_to_treesegment, TreeSegmentWidget
|
||
|
|
|
||
|
|
# Known bug: ChartView doesn't handle edges generated by epsilon
|
||
|
|
# productions (e.g., [Production: PP -> ]) very well.
|
||
|
|
|
||
|
|
#######################################################################
|
||
|
|
# Edge List
|
||
|
|
#######################################################################
|
||
|
|
|
||
|
|
class EdgeList(ColorizedList):
|
||
|
|
ARROW = SymbolWidget.SYMBOLS['rightarrow']
|
||
|
|
|
||
|
|
def _init_colortags(self, textwidget, options):
|
||
|
|
textwidget.tag_config('terminal', foreground='#006000')
|
||
|
|
textwidget.tag_config('arrow', font='symbol', underline='0')
|
||
|
|
textwidget.tag_config('dot', foreground = '#000000')
|
||
|
|
textwidget.tag_config('nonterminal', foreground='blue',
|
||
|
|
font=('helvetica', -12, 'bold'))
|
||
|
|
|
||
|
|
def _item_repr(self, item):
|
||
|
|
contents = []
|
||
|
|
contents.append(('%s\t' % item.lhs(), 'nonterminal'))
|
||
|
|
contents.append((self.ARROW, 'arrow'))
|
||
|
|
for i, elt in enumerate(item.rhs()):
|
||
|
|
if i == item.dot():
|
||
|
|
contents.append((' *', 'dot'))
|
||
|
|
if isinstance(elt, Nonterminal):
|
||
|
|
contents.append((' %s' % elt.symbol(), 'nonterminal'))
|
||
|
|
else:
|
||
|
|
contents.append((' %r' % elt, 'terminal'))
|
||
|
|
if item.is_complete():
|
||
|
|
contents.append((' *', 'dot'))
|
||
|
|
return contents
|
||
|
|
|
||
|
|
#######################################################################
|
||
|
|
# Chart Matrix View
|
||
|
|
#######################################################################
|
||
|
|
|
||
|
|
class ChartMatrixView(object):
|
||
|
|
"""
|
||
|
|
A view of a chart that displays the contents of the corresponding matrix.
|
||
|
|
"""
|
||
|
|
def __init__(self, parent, chart, toplevel=True, title='Chart Matrix',
|
||
|
|
show_numedges=False):
|
||
|
|
self._chart = chart
|
||
|
|
self._cells = []
|
||
|
|
self._marks = []
|
||
|
|
|
||
|
|
self._selected_cell = None
|
||
|
|
|
||
|
|
if toplevel:
|
||
|
|
self._root = Toplevel(parent)
|
||
|
|
self._root.title(title)
|
||
|
|
self._root.bind('<Control-q>', self.destroy)
|
||
|
|
self._init_quit(self._root)
|
||
|
|
else:
|
||
|
|
self._root = Frame(parent)
|
||
|
|
|
||
|
|
self._init_matrix(self._root)
|
||
|
|
self._init_list(self._root)
|
||
|
|
if show_numedges:
|
||
|
|
self._init_numedges(self._root)
|
||
|
|
else:
|
||
|
|
self._numedges_label = None
|
||
|
|
|
||
|
|
self._callbacks = {}
|
||
|
|
|
||
|
|
self._num_edges = 0
|
||
|
|
|
||
|
|
self.draw()
|
||
|
|
|
||
|
|
def _init_quit(self, root):
|
||
|
|
quit = Button(root, text='Quit', command=self.destroy)
|
||
|
|
quit.pack(side='bottom', expand=0, fill='none')
|
||
|
|
|
||
|
|
def _init_matrix(self, root):
|
||
|
|
cframe = Frame(root, border=2, relief='sunken')
|
||
|
|
cframe.pack(expand=0, fill='none', padx=1, pady=3, side='top')
|
||
|
|
self._canvas = Canvas(cframe, width=200, height=200,
|
||
|
|
background='white')
|
||
|
|
self._canvas.pack(expand=0, fill='none')
|
||
|
|
|
||
|
|
def _init_numedges(self, root):
|
||
|
|
self._numedges_label = Label(root, text='0 edges')
|
||
|
|
self._numedges_label.pack(expand=0, fill='none', side='top')
|
||
|
|
|
||
|
|
def _init_list(self, root):
|
||
|
|
self._list = EdgeList(root, [], width=20, height=5)
|
||
|
|
self._list.pack(side='top', expand=1, fill='both', pady=3)
|
||
|
|
def cb(edge, self=self): self._fire_callbacks('select', edge)
|
||
|
|
self._list.add_callback('select', cb)
|
||
|
|
self._list.focus()
|
||
|
|
|
||
|
|
def destroy(self, *e):
|
||
|
|
if self._root is None: return
|
||
|
|
try: self._root.destroy()
|
||
|
|
except: pass
|
||
|
|
self._root = None
|
||
|
|
|
||
|
|
def set_chart(self, chart):
|
||
|
|
if chart is not self._chart:
|
||
|
|
self._chart = chart
|
||
|
|
self._num_edges = 0
|
||
|
|
self.draw()
|
||
|
|
|
||
|
|
def update(self):
|
||
|
|
if self._root is None: return
|
||
|
|
|
||
|
|
# Count the edges in each cell
|
||
|
|
N = len(self._cells)
|
||
|
|
cell_edges = [[0 for i in range(N)] for j in range(N)]
|
||
|
|
for edge in self._chart:
|
||
|
|
cell_edges[edge.start()][edge.end()] += 1
|
||
|
|
|
||
|
|
# Color the cells correspondingly.
|
||
|
|
for i in range(N):
|
||
|
|
for j in range(i, N):
|
||
|
|
if cell_edges[i][j] == 0:
|
||
|
|
color = 'gray20'
|
||
|
|
else:
|
||
|
|
color = ('#00%02x%02x' %
|
||
|
|
(min(255, 50+128*cell_edges[i][j]/10),
|
||
|
|
max(0, 128-128*cell_edges[i][j]/10)))
|
||
|
|
cell_tag = self._cells[i][j]
|
||
|
|
self._canvas.itemconfig(cell_tag, fill=color)
|
||
|
|
if (i,j) == self._selected_cell:
|
||
|
|
self._canvas.itemconfig(cell_tag, outline='#00ffff',
|
||
|
|
width=3)
|
||
|
|
self._canvas.tag_raise(cell_tag)
|
||
|
|
else:
|
||
|
|
self._canvas.itemconfig(cell_tag, outline='black',
|
||
|
|
width=1)
|
||
|
|
|
||
|
|
# Update the edge list.
|
||
|
|
edges = list(self._chart.select(span=self._selected_cell))
|
||
|
|
self._list.set(edges)
|
||
|
|
|
||
|
|
# Update our edge count.
|
||
|
|
self._num_edges = self._chart.num_edges()
|
||
|
|
if self._numedges_label is not None:
|
||
|
|
self._numedges_label['text'] = '%d edges' % self._num_edges
|
||
|
|
|
||
|
|
def activate(self):
|
||
|
|
self._canvas.itemconfig('inactivebox', state='hidden')
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def inactivate(self):
|
||
|
|
self._canvas.itemconfig('inactivebox', state='normal')
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def add_callback(self, event, func):
|
||
|
|
self._callbacks.setdefault(event,{})[func] = 1
|
||
|
|
|
||
|
|
def remove_callback(self, event, func=None):
|
||
|
|
if func is None: del self._callbacks[event]
|
||
|
|
else:
|
||
|
|
try: del self._callbacks[event][func]
|
||
|
|
except: pass
|
||
|
|
|
||
|
|
def _fire_callbacks(self, event, *args):
|
||
|
|
if event not in self._callbacks: return
|
||
|
|
for cb_func in list(self._callbacks[event].keys()): cb_func(*args)
|
||
|
|
|
||
|
|
def select_cell(self, i, j):
|
||
|
|
if self._root is None: return
|
||
|
|
|
||
|
|
# If the cell is already selected (and the chart contents
|
||
|
|
# haven't changed), then do nothing.
|
||
|
|
if ((i,j) == self._selected_cell and
|
||
|
|
self._chart.num_edges() == self._num_edges): return
|
||
|
|
|
||
|
|
self._selected_cell = (i,j)
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
# Fire the callback.
|
||
|
|
self._fire_callbacks('select_cell', i, j)
|
||
|
|
|
||
|
|
def deselect_cell(self):
|
||
|
|
if self._root is None: return
|
||
|
|
self._selected_cell = None
|
||
|
|
self._list.set([])
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def _click_cell(self, i, j):
|
||
|
|
if self._selected_cell == (i,j):
|
||
|
|
self.deselect_cell()
|
||
|
|
else:
|
||
|
|
self.select_cell(i, j)
|
||
|
|
|
||
|
|
def view_edge(self, edge):
|
||
|
|
self.select_cell(*edge.span())
|
||
|
|
self._list.view(edge)
|
||
|
|
|
||
|
|
def mark_edge(self, edge):
|
||
|
|
if self._root is None: return
|
||
|
|
self.select_cell(*edge.span())
|
||
|
|
self._list.mark(edge)
|
||
|
|
|
||
|
|
def unmark_edge(self, edge=None):
|
||
|
|
if self._root is None: return
|
||
|
|
self._list.unmark(edge)
|
||
|
|
|
||
|
|
def markonly_edge(self, edge):
|
||
|
|
if self._root is None: return
|
||
|
|
self.select_cell(*edge.span())
|
||
|
|
self._list.markonly(edge)
|
||
|
|
|
||
|
|
def draw(self):
|
||
|
|
if self._root is None: return
|
||
|
|
LEFT_MARGIN = BOT_MARGIN = 15
|
||
|
|
TOP_MARGIN = 5
|
||
|
|
c = self._canvas
|
||
|
|
c.delete('all')
|
||
|
|
N = self._chart.num_leaves()+1
|
||
|
|
dx = (int(c['width'])-LEFT_MARGIN)/N
|
||
|
|
dy = (int(c['height'])-TOP_MARGIN-BOT_MARGIN)/N
|
||
|
|
|
||
|
|
c.delete('all')
|
||
|
|
|
||
|
|
# Labels and dotted lines
|
||
|
|
for i in range(N):
|
||
|
|
c.create_text(LEFT_MARGIN-2, i*dy+dy/2+TOP_MARGIN,
|
||
|
|
text=repr(i), anchor='e')
|
||
|
|
c.create_text(i*dx+dx/2+LEFT_MARGIN, N*dy+TOP_MARGIN+1,
|
||
|
|
text=repr(i), anchor='n')
|
||
|
|
c.create_line(LEFT_MARGIN, dy*(i+1)+TOP_MARGIN,
|
||
|
|
dx*N+LEFT_MARGIN, dy*(i+1)+TOP_MARGIN, dash='.')
|
||
|
|
c.create_line(dx*i+LEFT_MARGIN, TOP_MARGIN,
|
||
|
|
dx*i+LEFT_MARGIN, dy*N+TOP_MARGIN, dash='.')
|
||
|
|
|
||
|
|
# A box around the whole thing
|
||
|
|
c.create_rectangle(LEFT_MARGIN, TOP_MARGIN,
|
||
|
|
LEFT_MARGIN+dx*N, dy*N+TOP_MARGIN,
|
||
|
|
width=2)
|
||
|
|
|
||
|
|
# Cells
|
||
|
|
self._cells = [[None for i in range(N)] for j in range(N)]
|
||
|
|
for i in range(N):
|
||
|
|
for j in range(i, N):
|
||
|
|
t = c.create_rectangle(j*dx+LEFT_MARGIN, i*dy+TOP_MARGIN,
|
||
|
|
(j+1)*dx+LEFT_MARGIN,
|
||
|
|
(i+1)*dy+TOP_MARGIN,
|
||
|
|
fill='gray20')
|
||
|
|
self._cells[i][j] = t
|
||
|
|
def cb(event, self=self, i=i, j=j): self._click_cell(i,j)
|
||
|
|
c.tag_bind(t, '<Button-1>', cb)
|
||
|
|
|
||
|
|
# Inactive box
|
||
|
|
xmax, ymax = int(c['width']), int(c['height'])
|
||
|
|
t = c.create_rectangle(-100, -100, xmax+100, ymax+100,
|
||
|
|
fill='gray50', state='hidden',
|
||
|
|
tag='inactivebox')
|
||
|
|
c.tag_lower(t)
|
||
|
|
|
||
|
|
# Update the cells.
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def pack(self, *args, **kwargs):
|
||
|
|
self._root.pack(*args, **kwargs)
|
||
|
|
|
||
|
|
#######################################################################
|
||
|
|
# Chart Results View
|
||
|
|
#######################################################################
|
||
|
|
|
||
|
|
class ChartResultsView(object):
|
||
|
|
def __init__(self, parent, chart, grammar, toplevel=True):
|
||
|
|
self._chart = chart
|
||
|
|
self._grammar = grammar
|
||
|
|
self._trees = []
|
||
|
|
self._y = 10
|
||
|
|
self._treewidgets = []
|
||
|
|
self._selection = None
|
||
|
|
self._selectbox = None
|
||
|
|
|
||
|
|
if toplevel:
|
||
|
|
self._root = Toplevel(parent)
|
||
|
|
self._root.title('Chart Parser Application: Results')
|
||
|
|
self._root.bind('<Control-q>', self.destroy)
|
||
|
|
else:
|
||
|
|
self._root = Frame(parent)
|
||
|
|
|
||
|
|
# Buttons
|
||
|
|
if toplevel:
|
||
|
|
buttons = Frame(self._root)
|
||
|
|
buttons.pack(side='bottom', expand=0, fill='x')
|
||
|
|
Button(buttons, text='Quit',
|
||
|
|
command=self.destroy).pack(side='right')
|
||
|
|
Button(buttons, text='Print All',
|
||
|
|
command=self.print_all).pack(side='left')
|
||
|
|
Button(buttons, text='Print Selection',
|
||
|
|
command=self.print_selection).pack(side='left')
|
||
|
|
|
||
|
|
# Canvas frame.
|
||
|
|
self._cframe = CanvasFrame(self._root, closeenough=20)
|
||
|
|
self._cframe.pack(side='top', expand=1, fill='both')
|
||
|
|
|
||
|
|
# Initial update
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def update(self, edge=None):
|
||
|
|
if self._root is None: return
|
||
|
|
# If the edge isn't a parse edge, do nothing.
|
||
|
|
if edge is not None:
|
||
|
|
if edge.lhs() != self._grammar.start(): return
|
||
|
|
if edge.span() != (0, self._chart.num_leaves()): return
|
||
|
|
|
||
|
|
for parse in self._chart.parses(self._grammar.start()):
|
||
|
|
if parse not in self._trees:
|
||
|
|
self._add(parse)
|
||
|
|
|
||
|
|
def _add(self, parse):
|
||
|
|
# Add it to self._trees.
|
||
|
|
self._trees.append(parse)
|
||
|
|
|
||
|
|
# Create a widget for it.
|
||
|
|
c = self._cframe.canvas()
|
||
|
|
treewidget = tree_to_treesegment(c, parse)
|
||
|
|
|
||
|
|
# Add it to the canvas frame.
|
||
|
|
self._treewidgets.append(treewidget)
|
||
|
|
self._cframe.add_widget(treewidget, 10, self._y)
|
||
|
|
|
||
|
|
# Register callbacks.
|
||
|
|
treewidget.bind_click(self._click)
|
||
|
|
|
||
|
|
# Update y.
|
||
|
|
self._y = treewidget.bbox()[3] + 10
|
||
|
|
|
||
|
|
def _click(self, widget):
|
||
|
|
c = self._cframe.canvas()
|
||
|
|
if self._selection is not None:
|
||
|
|
c.delete(self._selectbox)
|
||
|
|
self._selection = widget
|
||
|
|
(x1, y1, x2, y2) = widget.bbox()
|
||
|
|
self._selectbox = c.create_rectangle(x1, y1, x2, y2,
|
||
|
|
width=2, outline='#088')
|
||
|
|
|
||
|
|
def _color(self, treewidget, color):
|
||
|
|
treewidget.label()['color'] = color
|
||
|
|
for child in treewidget.subtrees():
|
||
|
|
if isinstance(child, TreeSegmentWidget):
|
||
|
|
self._color(child, color)
|
||
|
|
else:
|
||
|
|
child['color'] = color
|
||
|
|
|
||
|
|
def print_all(self, *e):
|
||
|
|
if self._root is None: return
|
||
|
|
self._cframe.print_to_file()
|
||
|
|
|
||
|
|
def print_selection(self, *e):
|
||
|
|
if self._root is None: return
|
||
|
|
if self._selection is None:
|
||
|
|
showerror('Print Error', 'No tree selected')
|
||
|
|
else:
|
||
|
|
c = self._cframe.canvas()
|
||
|
|
for widget in self._treewidgets:
|
||
|
|
if widget is not self._selection:
|
||
|
|
self._cframe.destroy_widget(widget)
|
||
|
|
c.delete(self._selectbox)
|
||
|
|
(x1,y1,x2,y2) = self._selection.bbox()
|
||
|
|
self._selection.move(10-x1,10-y1)
|
||
|
|
c['scrollregion'] = '0 0 %s %s' % (x2-x1+20, y2-y1+20)
|
||
|
|
self._cframe.print_to_file()
|
||
|
|
|
||
|
|
# Restore our state.
|
||
|
|
self._treewidgets = [self._selection]
|
||
|
|
self.clear()
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def clear(self):
|
||
|
|
if self._root is None: return
|
||
|
|
for treewidget in self._treewidgets:
|
||
|
|
self._cframe.destroy_widget(treewidget)
|
||
|
|
self._trees = []
|
||
|
|
self._treewidgets = []
|
||
|
|
if self._selection is not None:
|
||
|
|
self._cframe.canvas().delete(self._selectbox)
|
||
|
|
self._selection = None
|
||
|
|
self._y = 10
|
||
|
|
|
||
|
|
def set_chart(self, chart):
|
||
|
|
self.clear()
|
||
|
|
self._chart = chart
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def set_grammar(self, grammar):
|
||
|
|
self.clear()
|
||
|
|
self._grammar = grammar
|
||
|
|
self.update()
|
||
|
|
|
||
|
|
def destroy(self, *e):
|
||
|
|
if self._root is None: return
|
||
|
|
try: self._root.destroy()
|
||
|
|
except: pass
|
||
|
|
self._root = None
|
||
|
|
|
||
|
|
def pack(self, *args, **kwargs):
|
||
|
|
self._root.pack(*args, **kwargs)
|
||
|
|
|
||
|
|
#######################################################################
|
||
|
|
# Chart Comparer
|
||
|
|
#######################################################################
|
||
|
|
|
||
|
|
class ChartComparer(object):
|
||
|
|
"""
|
||
|
|
|
||
|
|
:ivar _root: The root window
|
||
|
|
|
||
|
|
:ivar _charts: A dictionary mapping names to charts. When
|
||
|
|
charts are loaded, they are added to this dictionary.
|
||
|
|
|
||
|
|
:ivar _left_chart: The left ``Chart``.
|
||
|
|
:ivar _left_name: The name ``_left_chart`` (derived from filename)
|
||
|
|
:ivar _left_matrix: The ``ChartMatrixView`` for ``_left_chart``
|
||
|
|
:ivar _left_selector: The drop-down ``MutableOptionsMenu`` used
|
||
|
|
to select ``_left_chart``.
|
||
|
|
|
||
|
|
:ivar _right_chart: The right ``Chart``.
|
||
|
|
:ivar _right_name: The name ``_right_chart`` (derived from filename)
|
||
|
|
:ivar _right_matrix: The ``ChartMatrixView`` for ``_right_chart``
|
||
|
|
:ivar _right_selector: The drop-down ``MutableOptionsMenu`` used
|
||
|
|
to select ``_right_chart``.
|
||
|
|
|
||
|
|
:ivar _out_chart: The out ``Chart``.
|
||
|
|
:ivar _out_name: The name ``_out_chart`` (derived from filename)
|
||
|
|
:ivar _out_matrix: The ``ChartMatrixView`` for ``_out_chart``
|
||
|
|
:ivar _out_label: The label for ``_out_chart``.
|
||
|
|
|
||
|
|
:ivar _op_label: A Label containing the most recent operation.
|
||
|
|
"""
|
||
|
|
|
||
|
|
_OPSYMBOL = {'-': '-',
|
||
|
|
'and': SymbolWidget.SYMBOLS['intersection'],
|
||
|
|
'or': SymbolWidget.SYMBOLS['union']}
|
||
|
|
|
||
|
|
def __init__(self, *chart_filenames):
|
||
|
|
# This chart is displayed when we don't have a value (eg
|
||
|
|
# before any chart is loaded).
|
||
|
|
faketok = [''] * 8
|
||
|
|
self._emptychart = Chart(faketok)
|
||
|
|
|
||
|
|
# The left & right charts start out empty.
|
||
|
|
self._left_name = 'None'
|
||
|
|
self._right_name = 'None'
|
||
|
|
self._left_chart = self._emptychart
|
||
|
|
self._right_chart = self._emptychart
|
||
|
|
|
||
|
|
# The charts that have been loaded.
|
||
|
|
self._charts = {'None': self._emptychart}
|
||
|
|
|
||
|
|
# The output chart.
|
||
|
|
self._out_chart = self._emptychart
|
||
|
|
|
||
|
|
# The most recent operation
|
||
|
|
self._operator = None
|
||
|
|
|
||
|
|
# Set up the root window.
|
||
|
|
self._root = Tk()
|
||
|
|
self._root.title('Chart Comparison')
|
||
|
|
self._root.bind('<Control-q>', self.destroy)
|
||
|
|
self._root.bind('<Control-x>', self.destroy)
|
||
|
|
|
||
|
|
# Initialize all widgets, etc.
|
||
|
|
self._init_menubar(self._root)
|
||
|
|
self._init_chartviews(self._root)
|
||
|
|
self._init_divider(self._root)
|
||
|
|
self._init_buttons(self._root)
|
||
|
|
self._init_bindings(self._root)
|
||
|
|
|
||
|
|
# Load any specified charts.
|
||
|
|
for filename in chart_filenames:
|
||
|
|
self.load_chart(filename)
|
||
|
|
|
||
|
|
def destroy(self, *e):
|
||
|
|
if self._root is None: return
|
||
|
|
try: self._root.destroy()
|
||
|
|
except: pass
|
||
|
|
self._root = None
|
||
|
|
|
||
|
|
def mainloop(self, *args, **kwargs):
|
||
|
|
return
|
||
|
|
self._root.mainloop(*args, **kwargs)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Initialization
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def _init_menubar(self, root):
|
||
|
|
menubar = Menu(root)
|
||
|
|
|
||
|
|
# File menu
|
||
|
|
filemenu = Menu(menubar, tearoff=0)
|
||
|
|
filemenu.add_command(label='Load Chart', accelerator='Ctrl-o',
|
||
|
|
underline=0, command=self.load_chart_dialog)
|
||
|
|
filemenu.add_command(label='Save Output', accelerator='Ctrl-s',
|
||
|
|
underline=0, command=self.save_chart_dialog)
|
||
|
|
filemenu.add_separator()
|
||
|
|
filemenu.add_command(label='Exit', underline=1,
|
||
|
|
command=self.destroy, accelerator='Ctrl-x')
|
||
|
|
menubar.add_cascade(label='File', underline=0, menu=filemenu)
|
||
|
|
|
||
|
|
# Compare menu
|
||
|
|
opmenu = Menu(menubar, tearoff=0)
|
||
|
|
opmenu.add_command(label='Intersection',
|
||
|
|
command=self._intersection,
|
||
|
|
accelerator='+')
|
||
|
|
opmenu.add_command(label='Union',
|
||
|
|
command=self._union,
|
||
|
|
accelerator='*')
|
||
|
|
opmenu.add_command(label='Difference',
|
||
|
|
command=self._difference,
|
||
|
|
accelerator='-')
|
||
|
|
opmenu.add_separator()
|
||
|
|
opmenu.add_command(label='Swap Charts',
|
||
|
|
command=self._swapcharts)
|
||
|
|
menubar.add_cascade(label='Compare', underline=0, menu=opmenu)
|
||
|
|
|
||
|
|
# Add the menu
|
||
|
|
self._root.config(menu=menubar)
|
||
|
|
|
||
|
|
def _init_divider(self, root):
|
||
|
|
divider = Frame(root, border=2, relief='sunken')
|
||
|
|
divider.pack(side='top', fill='x', ipady=2)
|
||
|
|
|
||
|
|
def _init_chartviews(self, root):
|
||
|
|
opfont=('symbol', -36) # Font for operator.
|
||
|
|
eqfont=('helvetica', -36) # Font for equals sign.
|
||
|
|
|
||
|
|
frame = Frame(root, background='#c0c0c0')
|
||
|
|
frame.pack(side='top', expand=1, fill='both')
|
||
|
|
|
||
|
|
# The left matrix.
|
||
|
|
cv1_frame = Frame(frame, border=3, relief='groove')
|
||
|
|
cv1_frame.pack(side='left', padx=8, pady=7, expand=1, fill='both')
|
||
|
|
self._left_selector = MutableOptionMenu(
|
||
|
|
cv1_frame, list(self._charts.keys()), command=self._select_left)
|
||
|
|
self._left_selector.pack(side='top', pady=5, fill='x')
|
||
|
|
self._left_matrix = ChartMatrixView(cv1_frame, self._emptychart,
|
||
|
|
toplevel=False,
|
||
|
|
show_numedges=True)
|
||
|
|
self._left_matrix.pack(side='bottom', padx=5, pady=5,
|
||
|
|
expand=1, fill='both')
|
||
|
|
self._left_matrix.add_callback('select', self.select_edge)
|
||
|
|
self._left_matrix.add_callback('select_cell', self.select_cell)
|
||
|
|
self._left_matrix.inactivate()
|
||
|
|
|
||
|
|
# The operator.
|
||
|
|
self._op_label = Label(frame, text=' ', width=3,
|
||
|
|
background='#c0c0c0', font=opfont)
|
||
|
|
self._op_label.pack(side='left', padx=5, pady=5)
|
||
|
|
|
||
|
|
# The right matrix.
|
||
|
|
cv2_frame = Frame(frame, border=3, relief='groove')
|
||
|
|
cv2_frame.pack(side='left', padx=8, pady=7, expand=1, fill='both')
|
||
|
|
self._right_selector = MutableOptionMenu(
|
||
|
|
cv2_frame, list(self._charts.keys()), command=self._select_right)
|
||
|
|
self._right_selector.pack(side='top', pady=5, fill='x')
|
||
|
|
self._right_matrix = ChartMatrixView(cv2_frame, self._emptychart,
|
||
|
|
toplevel=False,
|
||
|
|
show_numedges=True)
|
||
|
|
self._right_matrix.pack(side='bottom', padx=5, pady=5,
|
||
|
|
expand=1, fill='both')
|
||
|
|
self._right_matrix.add_callback('select', self.select_edge)
|
||
|
|
self._right_matrix.add_callback('select_cell', self.select_cell)
|
||
|
|
self._right_matrix.inactivate()
|
||
|
|
|
||
|
|
# The equals sign
|
||
|
|
Label(frame, text='=', width=3, background='#c0c0c0',
|
||
|
|
font=eqfont).pack(side='left', padx=5, pady=5)
|
||
|
|
|
||
|
|
# The output matrix.
|
||
|
|
out_frame = Frame(frame, border=3, relief='groove')
|
||
|
|
out_frame.pack(side='left', padx=8, pady=7, expand=1, fill='both')
|
||
|
|
self._out_label = Label(out_frame, text='Output')
|
||
|
|
self._out_label.pack(side='top', pady=9)
|
||
|
|
self._out_matrix = ChartMatrixView(out_frame, self._emptychart,
|
||
|
|
toplevel=False,
|
||
|
|
show_numedges=True)
|
||
|
|
self._out_matrix.pack(side='bottom', padx=5, pady=5,
|
||
|
|
expand=1, fill='both')
|
||
|
|
self._out_matrix.add_callback('select', self.select_edge)
|
||
|
|
self._out_matrix.add_callback('select_cell', self.select_cell)
|
||
|
|
self._out_matrix.inactivate()
|
||
|
|
|
||
|
|
def _init_buttons(self, root):
|
||
|
|
buttons = Frame(root)
|
||
|
|
buttons.pack(side='bottom', pady=5, fill='x', expand=0)
|
||
|
|
Button(buttons, text='Intersection',
|
||
|
|
command=self._intersection).pack(side='left')
|
||
|
|
Button(buttons, text='Union',
|
||
|
|
command=self._union).pack(side='left')
|
||
|
|
Button(buttons, text='Difference',
|
||
|
|
command=self._difference).pack(side='left')
|
||
|
|
Frame(buttons, width=20).pack(side='left')
|
||
|
|
Button(buttons, text='Swap Charts',
|
||
|
|
command=self._swapcharts).pack(side='left')
|
||
|
|
|
||
|
|
Button(buttons, text='Detatch Output',
|
||
|
|
command=self._detatch_out).pack(side='right')
|
||
|
|
|
||
|
|
def _init_bindings(self, root):
|
||
|
|
#root.bind('<Control-s>', self.save_chart)
|
||
|
|
root.bind('<Control-o>', self.load_chart_dialog)
|
||
|
|
#root.bind('<Control-r>', self.reset)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Input Handling
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def _select_left(self, name):
|
||
|
|
self._left_name = name
|
||
|
|
self._left_chart = self._charts[name]
|
||
|
|
self._left_matrix.set_chart(self._left_chart)
|
||
|
|
if name == 'None': self._left_matrix.inactivate()
|
||
|
|
self._apply_op()
|
||
|
|
|
||
|
|
def _select_right(self, name):
|
||
|
|
self._right_name = name
|
||
|
|
self._right_chart = self._charts[name]
|
||
|
|
self._right_matrix.set_chart(self._right_chart)
|
||
|
|
if name == 'None': self._right_matrix.inactivate()
|
||
|
|
self._apply_op()
|
||
|
|
|
||
|
|
def _apply_op(self):
|
||
|
|
if self._operator == '-': self._difference()
|
||
|
|
elif self._operator == 'or': self._union()
|
||
|
|
elif self._operator == 'and': self._intersection()
|
||
|
|
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# File
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
CHART_FILE_TYPES = [('Pickle file', '.pickle'),
|
||
|
|
('All files', '*')]
|
||
|
|
|
||
|
|
def save_chart_dialog(self, *args):
|
||
|
|
filename = asksaveasfilename(filetypes=self.CHART_FILE_TYPES,
|
||
|
|
defaultextension='.pickle')
|
||
|
|
if not filename: return
|
||
|
|
try:
|
||
|
|
with open(filename, 'wb') as outfile:
|
||
|
|
pickle.dump(self._out_chart, outfile)
|
||
|
|
except Exception as e:
|
||
|
|
showerror('Error Saving Chart',
|
||
|
|
'Unable to open file: %r\n%s' %
|
||
|
|
(filename, e))
|
||
|
|
|
||
|
|
def load_chart_dialog(self, *args):
|
||
|
|
filename = askopenfilename(filetypes=self.CHART_FILE_TYPES,
|
||
|
|
defaultextension='.pickle')
|
||
|
|
if not filename: return
|
||
|
|
try: self.load_chart(filename)
|
||
|
|
except Exception as e:
|
||
|
|
showerror('Error Loading Chart',
|
||
|
|
'Unable to open file: %r\n%s' %
|
||
|
|
(filename, e))
|
||
|
|
|
||
|
|
def load_chart(self, filename):
|
||
|
|
with open(filename, 'rb') as infile:
|
||
|
|
chart = pickle.load(infile)
|
||
|
|
name = os.path.basename(filename)
|
||
|
|
if name.endswith('.pickle'): name = name[:-7]
|
||
|
|
if name.endswith('.chart'): name = name[:-6]
|
||
|
|
self._charts[name] = chart
|
||
|
|
self._left_selector.add(name)
|
||
|
|
self._right_selector.add(name)
|
||
|
|
|
||
|
|
# If either left_matrix or right_matrix is empty, then
|
||
|
|
# display the new chart.
|
||
|
|
if self._left_chart is self._emptychart:
|
||
|
|
self._left_selector.set(name)
|
||
|
|
elif self._right_chart is self._emptychart:
|
||
|
|
self._right_selector.set(name)
|
||
|
|
|
||
|
|
def _update_chartviews(self):
|
||
|
|
self._left_matrix.update()
|
||
|
|
self._right_matrix.update()
|
||
|
|
self._out_matrix.update()
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Selection
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def select_edge(self, edge):
|
||
|
|
if edge in self._left_chart:
|
||
|
|
self._left_matrix.markonly_edge(edge)
|
||
|
|
else:
|
||
|
|
self._left_matrix.unmark_edge()
|
||
|
|
if edge in self._right_chart:
|
||
|
|
self._right_matrix.markonly_edge(edge)
|
||
|
|
else:
|
||
|
|
self._right_matrix.unmark_edge()
|
||
|
|
if edge in self._out_chart:
|
||
|
|
self._out_matrix.markonly_edge(edge)
|
||
|
|
else:
|
||
|
|
self._out_matrix.unmark_edge()
|
||
|
|
|
||
|
|
def select_cell(self, i, j):
|
||
|
|
self._left_matrix.select_cell(i, j)
|
||
|
|
self._right_matrix.select_cell(i, j)
|
||
|
|
self._out_matrix.select_cell(i, j)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Operations
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def _difference(self):
|
||
|
|
if not self._checkcompat(): return
|
||
|
|
|
||
|
|
out_chart = Chart(self._left_chart.tokens())
|
||
|
|
for edge in self._left_chart:
|
||
|
|
if edge not in self._right_chart:
|
||
|
|
out_chart.insert(edge, [])
|
||
|
|
|
||
|
|
self._update('-', out_chart)
|
||
|
|
|
||
|
|
def _intersection(self):
|
||
|
|
if not self._checkcompat(): return
|
||
|
|
|
||
|
|
out_chart = Chart(self._left_chart.tokens())
|
||
|
|
for edge in self._left_chart:
|
||
|
|
if edge in self._right_chart:
|
||
|
|
out_chart.insert(edge, [])
|
||
|
|
|
||
|
|
self._update('and', out_chart)
|
||
|
|
|
||
|
|
def _union(self):
|
||
|
|
if not self._checkcompat(): return
|
||
|
|
|
||
|
|
out_chart = Chart(self._left_chart.tokens())
|
||
|
|
for edge in self._left_chart:
|
||
|
|
out_chart.insert(edge, [])
|
||
|
|
for edge in self._right_chart:
|
||
|
|
out_chart.insert(edge, [])
|
||
|
|
|
||
|
|
self._update('or', out_chart)
|
||
|
|
|
||
|
|
def _swapcharts(self):
|
||
|
|
left, right = self._left_name, self._right_name
|
||
|
|
self._left_selector.set(right)
|
||
|
|
self._right_selector.set(left)
|
||
|
|
|
||
|
|
def _checkcompat(self):
|
||
|
|
if (self._left_chart.tokens() != self._right_chart.tokens() or
|
||
|
|
self._left_chart.property_names() !=
|
||
|
|
self._right_chart.property_names() or
|
||
|
|
self._left_chart == self._emptychart or
|
||
|
|
self._right_chart == self._emptychart):
|
||
|
|
# Clear & inactivate the output chart.
|
||
|
|
self._out_chart = self._emptychart
|
||
|
|
self._out_matrix.set_chart(self._out_chart)
|
||
|
|
self._out_matrix.inactivate()
|
||
|
|
self._out_label['text'] = 'Output'
|
||
|
|
# Issue some other warning?
|
||
|
|
return False
|
||
|
|
else:
|
||
|
|
return True
|
||
|
|
|
||
|
|
def _update(self, operator, out_chart):
|
||
|
|
self._operator = operator
|
||
|
|
self._op_label['text'] = self._OPSYMBOL[operator]
|
||
|
|
self._out_chart = out_chart
|
||
|
|
self._out_matrix.set_chart(out_chart)
|
||
|
|
self._out_label['text'] = '%s %s %s' % (self._left_name,
|
||
|
|
self._operator,
|
||
|
|
self._right_name)
|
||
|
|
|
||
|
|
def _clear_out_chart(self):
|
||
|
|
self._out_chart = self._emptychart
|
||
|
|
self._out_matrix.set_chart(self._out_chart)
|
||
|
|
self._op_label['text'] = ' '
|
||
|
|
self._out_matrix.inactivate()
|
||
|
|
|
||
|
|
def _detatch_out(self):
|
||
|
|
ChartMatrixView(self._root, self._out_chart,
|
||
|
|
title=self._out_label['text'])
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
#######################################################################
|
||
|
|
# Chart View
|
||
|
|
#######################################################################
|
||
|
|
|
||
|
|
class ChartView(object):
|
||
|
|
"""
|
||
|
|
A component for viewing charts. This is used by ``ChartParserApp`` to
|
||
|
|
allow students to interactively experiment with various chart
|
||
|
|
parsing techniques. It is also used by ``Chart.draw()``.
|
||
|
|
|
||
|
|
:ivar _chart: The chart that we are giving a view of. This chart
|
||
|
|
may be modified; after it is modified, you should call
|
||
|
|
``update``.
|
||
|
|
:ivar _sentence: The list of tokens that the chart spans.
|
||
|
|
|
||
|
|
:ivar _root: The root window.
|
||
|
|
:ivar _chart_canvas: The canvas we're using to display the chart
|
||
|
|
itself.
|
||
|
|
:ivar _tree_canvas: The canvas we're using to display the tree
|
||
|
|
that each edge spans. May be None, if we're not displaying
|
||
|
|
trees.
|
||
|
|
:ivar _sentence_canvas: The canvas we're using to display the sentence
|
||
|
|
text. May be None, if we're not displaying the sentence text.
|
||
|
|
:ivar _edgetags: A dictionary mapping from edges to the tags of
|
||
|
|
the canvas elements (lines, etc) used to display that edge.
|
||
|
|
The values of this dictionary have the form
|
||
|
|
``(linetag, rhstag1, dottag, rhstag2, lhstag)``.
|
||
|
|
:ivar _treetags: A list of all the tags that make up the tree;
|
||
|
|
used to erase the tree (without erasing the loclines).
|
||
|
|
:ivar _chart_height: The height of the chart canvas.
|
||
|
|
:ivar _sentence_height: The height of the sentence canvas.
|
||
|
|
:ivar _tree_height: The height of the tree
|
||
|
|
|
||
|
|
:ivar _text_height: The height of a text string (in the normal
|
||
|
|
font).
|
||
|
|
|
||
|
|
:ivar _edgelevels: A list of edges at each level of the chart (the
|
||
|
|
top level is the 0th element). This list is used to remember
|
||
|
|
where edges should be drawn; and to make sure that no edges
|
||
|
|
are overlapping on the chart view.
|
||
|
|
|
||
|
|
:ivar _unitsize: Pixel size of one unit (from the location). This
|
||
|
|
is determined by the span of the chart's location, and the
|
||
|
|
width of the chart display canvas.
|
||
|
|
|
||
|
|
:ivar _fontsize: The current font size
|
||
|
|
|
||
|
|
:ivar _marks: A dictionary from edges to marks. Marks are
|
||
|
|
strings, specifying colors (e.g. 'green').
|
||
|
|
"""
|
||
|
|
|
||
|
|
_LEAF_SPACING = 10
|
||
|
|
_MARGIN = 10
|
||
|
|
_TREE_LEVEL_SIZE = 12
|
||
|
|
_CHART_LEVEL_SIZE = 40
|
||
|
|
|
||
|
|
def __init__(self, chart, root=None, **kw):
|
||
|
|
"""
|
||
|
|
Construct a new ``Chart`` display.
|
||
|
|
"""
|
||
|
|
# Process keyword args.
|
||
|
|
draw_tree = kw.get('draw_tree', 0)
|
||
|
|
draw_sentence = kw.get('draw_sentence', 1)
|
||
|
|
self._fontsize = kw.get('fontsize', -12)
|
||
|
|
|
||
|
|
# The chart!
|
||
|
|
self._chart = chart
|
||
|
|
|
||
|
|
# Callback functions
|
||
|
|
self._callbacks = {}
|
||
|
|
|
||
|
|
# Keep track of drawn edges
|
||
|
|
self._edgelevels = []
|
||
|
|
self._edgetags = {}
|
||
|
|
|
||
|
|
# Keep track of which edges are marked.
|
||
|
|
self._marks = {}
|
||
|
|
|
||
|
|
# These are used to keep track of the set of tree tokens
|
||
|
|
# currently displayed in the tree canvas.
|
||
|
|
self._treetoks = []
|
||
|
|
self._treetoks_edge = None
|
||
|
|
self._treetoks_index = 0
|
||
|
|
|
||
|
|
# Keep track of the tags used to draw the tree
|
||
|
|
self._tree_tags = []
|
||
|
|
|
||
|
|
# Put multiple edges on each level?
|
||
|
|
self._compact = 0
|
||
|
|
|
||
|
|
# If they didn't provide a main window, then set one up.
|
||
|
|
if root is None:
|
||
|
|
top = Tk()
|
||
|
|
top.title('Chart View')
|
||
|
|
def destroy1(e, top=top): top.destroy()
|
||
|
|
def destroy2(top=top): top.destroy()
|
||
|
|
top.bind('q', destroy1)
|
||
|
|
b = Button(top, text='Done', command=destroy2)
|
||
|
|
b.pack(side='bottom')
|
||
|
|
self._root = top
|
||
|
|
else:
|
||
|
|
self._root = root
|
||
|
|
|
||
|
|
# Create some fonts.
|
||
|
|
self._init_fonts(root)
|
||
|
|
|
||
|
|
# Create the chart canvas.
|
||
|
|
(self._chart_sb, self._chart_canvas) = self._sb_canvas(self._root)
|
||
|
|
self._chart_canvas['height'] = 300
|
||
|
|
self._chart_canvas['closeenough'] = 15
|
||
|
|
|
||
|
|
# Create the sentence canvas.
|
||
|
|
if draw_sentence:
|
||
|
|
cframe = Frame(self._root, relief='sunk', border=2)
|
||
|
|
cframe.pack(fill='both', side='bottom')
|
||
|
|
self._sentence_canvas = Canvas(cframe, height=50)
|
||
|
|
self._sentence_canvas['background'] = '#e0e0e0'
|
||
|
|
self._sentence_canvas.pack(fill='both')
|
||
|
|
#self._sentence_canvas['height'] = self._sentence_height
|
||
|
|
else:
|
||
|
|
self._sentence_canvas = None
|
||
|
|
|
||
|
|
# Create the tree canvas.
|
||
|
|
if draw_tree:
|
||
|
|
(sb, canvas) = self._sb_canvas(self._root, 'n', 'x')
|
||
|
|
(self._tree_sb, self._tree_canvas) = (sb, canvas)
|
||
|
|
self._tree_canvas['height'] = 200
|
||
|
|
else:
|
||
|
|
self._tree_canvas = None
|
||
|
|
|
||
|
|
# Do some analysis to figure out how big the window should be
|
||
|
|
self._analyze()
|
||
|
|
self.draw()
|
||
|
|
self._resize()
|
||
|
|
self._grow()
|
||
|
|
|
||
|
|
# Set up the configure callback, which will be called whenever
|
||
|
|
# the window is resized.
|
||
|
|
self._chart_canvas.bind('<Configure>', self._configure)
|
||
|
|
|
||
|
|
def _init_fonts(self, root):
|
||
|
|
self._boldfont = Font(family='helvetica', weight='bold',
|
||
|
|
size=self._fontsize)
|
||
|
|
self._font = Font(family='helvetica',
|
||
|
|
size=self._fontsize)
|
||
|
|
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
|
||
|
|
self._sysfont = Font(font=Button()["font"])
|
||
|
|
root.option_add("*Font", self._sysfont)
|
||
|
|
|
||
|
|
def _sb_canvas(self, root, expand='y',
|
||
|
|
fill='both', side='bottom'):
|
||
|
|
"""
|
||
|
|
Helper for __init__: construct a canvas with a scrollbar.
|
||
|
|
"""
|
||
|
|
cframe = Frame(root, relief='sunk', border=2)
|
||
|
|
cframe.pack(fill=fill, expand=expand, side=side)
|
||
|
|
canvas = Canvas(cframe, background='#e0e0e0')
|
||
|
|
|
||
|
|
# Give the canvas a scrollbar.
|
||
|
|
sb = Scrollbar(cframe, orient='vertical')
|
||
|
|
sb.pack(side='right', fill='y')
|
||
|
|
canvas.pack(side='left', fill=fill, expand='yes')
|
||
|
|
|
||
|
|
# Connect the scrollbars to the canvas.
|
||
|
|
sb['command']= canvas.yview
|
||
|
|
canvas['yscrollcommand'] = sb.set
|
||
|
|
|
||
|
|
return (sb, canvas)
|
||
|
|
|
||
|
|
def scroll_up(self, *e):
|
||
|
|
self._chart_canvas.yview('scroll', -1, 'units')
|
||
|
|
|
||
|
|
def scroll_down(self, *e):
|
||
|
|
self._chart_canvas.yview('scroll', 1, 'units')
|
||
|
|
|
||
|
|
def page_up(self, *e):
|
||
|
|
self._chart_canvas.yview('scroll', -1, 'pages')
|
||
|
|
|
||
|
|
def page_down(self, *e):
|
||
|
|
self._chart_canvas.yview('scroll', 1, 'pages')
|
||
|
|
|
||
|
|
def _grow(self):
|
||
|
|
"""
|
||
|
|
Grow the window, if necessary
|
||
|
|
"""
|
||
|
|
# Grow, if need-be
|
||
|
|
N = self._chart.num_leaves()
|
||
|
|
width = max(int(self._chart_canvas['width']),
|
||
|
|
N * self._unitsize + ChartView._MARGIN * 2 )
|
||
|
|
|
||
|
|
# It won't resize without the second (height) line, but I
|
||
|
|
# don't understand why not.
|
||
|
|
self._chart_canvas.configure(width=width)
|
||
|
|
self._chart_canvas.configure(height=self._chart_canvas['height'])
|
||
|
|
|
||
|
|
self._unitsize = (width - 2*ChartView._MARGIN) / N
|
||
|
|
|
||
|
|
# Reset the height for the sentence window.
|
||
|
|
if self._sentence_canvas is not None:
|
||
|
|
self._sentence_canvas['height'] = self._sentence_height
|
||
|
|
|
||
|
|
def set_font_size(self, size):
|
||
|
|
self._font.configure(size=-abs(size))
|
||
|
|
self._boldfont.configure(size=-abs(size))
|
||
|
|
self._sysfont.configure(size=-abs(size))
|
||
|
|
self._analyze()
|
||
|
|
self._grow()
|
||
|
|
self.draw()
|
||
|
|
|
||
|
|
def get_font_size(self):
|
||
|
|
return abs(self._fontsize)
|
||
|
|
|
||
|
|
def _configure(self, e):
|
||
|
|
"""
|
||
|
|
The configure callback. This is called whenever the window is
|
||
|
|
resized. It is also called when the window is first mapped.
|
||
|
|
It figures out the unit size, and redraws the contents of each
|
||
|
|
canvas.
|
||
|
|
"""
|
||
|
|
N = self._chart.num_leaves()
|
||
|
|
self._unitsize = (e.width - 2*ChartView._MARGIN) / N
|
||
|
|
self.draw()
|
||
|
|
|
||
|
|
def update(self, chart=None):
|
||
|
|
"""
|
||
|
|
Draw any edges that have not been drawn. This is typically
|
||
|
|
called when a after modifies the canvas that a CanvasView is
|
||
|
|
displaying. ``update`` will cause any edges that have been
|
||
|
|
added to the chart to be drawn.
|
||
|
|
|
||
|
|
If update is given a ``chart`` argument, then it will replace
|
||
|
|
the current chart with the given chart.
|
||
|
|
"""
|
||
|
|
if chart is not None:
|
||
|
|
self._chart = chart
|
||
|
|
self._edgelevels = []
|
||
|
|
self._marks = {}
|
||
|
|
self._analyze()
|
||
|
|
self._grow()
|
||
|
|
self.draw()
|
||
|
|
self.erase_tree()
|
||
|
|
self._resize()
|
||
|
|
else:
|
||
|
|
for edge in self._chart:
|
||
|
|
if edge not in self._edgetags:
|
||
|
|
self._add_edge(edge)
|
||
|
|
self._resize()
|
||
|
|
|
||
|
|
|
||
|
|
def _edge_conflict(self, edge, lvl):
|
||
|
|
"""
|
||
|
|
Return True if the given edge overlaps with any edge on the given
|
||
|
|
level. This is used by _add_edge to figure out what level a
|
||
|
|
new edge should be added to.
|
||
|
|
"""
|
||
|
|
(s1, e1) = edge.span()
|
||
|
|
for otheredge in self._edgelevels[lvl]:
|
||
|
|
(s2, e2) = otheredge.span()
|
||
|
|
if (s1 <= s2 < e1) or (s2 <= s1 < e2) or (s1==s2==e1==e2):
|
||
|
|
return True
|
||
|
|
return False
|
||
|
|
|
||
|
|
def _analyze_edge(self, edge):
|
||
|
|
"""
|
||
|
|
Given a new edge, recalculate:
|
||
|
|
|
||
|
|
- _text_height
|
||
|
|
- _unitsize (if the edge text is too big for the current
|
||
|
|
_unitsize, then increase _unitsize)
|
||
|
|
"""
|
||
|
|
c = self._chart_canvas
|
||
|
|
|
||
|
|
if isinstance(edge, TreeEdge):
|
||
|
|
lhs = edge.lhs()
|
||
|
|
rhselts = []
|
||
|
|
for elt in edge.rhs():
|
||
|
|
if isinstance(elt, Nonterminal):
|
||
|
|
rhselts.append(str(elt.symbol()))
|
||
|
|
else:
|
||
|
|
rhselts.append(repr(elt))
|
||
|
|
rhs = " ".join(rhselts)
|
||
|
|
else:
|
||
|
|
lhs = edge.lhs()
|
||
|
|
rhs = ''
|
||
|
|
|
||
|
|
for s in (lhs, rhs):
|
||
|
|
tag = c.create_text(0,0, text=s,
|
||
|
|
font=self._boldfont,
|
||
|
|
anchor='nw', justify='left')
|
||
|
|
bbox = c.bbox(tag)
|
||
|
|
c.delete(tag)
|
||
|
|
width = bbox[2] #+ ChartView._LEAF_SPACING
|
||
|
|
edgelen = max(edge.length(), 1)
|
||
|
|
self._unitsize = max(self._unitsize, width/edgelen)
|
||
|
|
self._text_height = max(self._text_height, bbox[3] - bbox[1])
|
||
|
|
|
||
|
|
def _add_edge(self, edge, minlvl=0):
|
||
|
|
"""
|
||
|
|
Add a single edge to the ChartView:
|
||
|
|
|
||
|
|
- Call analyze_edge to recalculate display parameters
|
||
|
|
- Find an available level
|
||
|
|
- Call _draw_edge
|
||
|
|
"""
|
||
|
|
# Do NOT show leaf edges in the chart.
|
||
|
|
if isinstance(edge, LeafEdge): return
|
||
|
|
|
||
|
|
if edge in self._edgetags: return
|
||
|
|
self._analyze_edge(edge)
|
||
|
|
self._grow()
|
||
|
|
|
||
|
|
if not self._compact:
|
||
|
|
self._edgelevels.append([edge])
|
||
|
|
lvl = len(self._edgelevels)-1
|
||
|
|
self._draw_edge(edge, lvl)
|
||
|
|
self._resize()
|
||
|
|
return
|
||
|
|
|
||
|
|
# Figure out what level to draw the edge on.
|
||
|
|
lvl = 0
|
||
|
|
while True:
|
||
|
|
# If this level doesn't exist yet, create it.
|
||
|
|
while lvl >= len(self._edgelevels):
|
||
|
|
self._edgelevels.append([])
|
||
|
|
self._resize()
|
||
|
|
|
||
|
|
# Check if we can fit the edge in this level.
|
||
|
|
if lvl>=minlvl and not self._edge_conflict(edge, lvl):
|
||
|
|
# Go ahead and draw it.
|
||
|
|
self._edgelevels[lvl].append(edge)
|
||
|
|
break
|
||
|
|
|
||
|
|
# Try the next level.
|
||
|
|
lvl += 1
|
||
|
|
|
||
|
|
self._draw_edge(edge, lvl)
|
||
|
|
|
||
|
|
def view_edge(self, edge):
|
||
|
|
level = None
|
||
|
|
for i in range(len(self._edgelevels)):
|
||
|
|
if edge in self._edgelevels[i]:
|
||
|
|
level = i
|
||
|
|
break
|
||
|
|
if level is None: return
|
||
|
|
# Try to view the new edge..
|
||
|
|
y = (level+1) * self._chart_level_size
|
||
|
|
dy = self._text_height + 10
|
||
|
|
self._chart_canvas.yview('moveto', 1.0)
|
||
|
|
if self._chart_height != 0:
|
||
|
|
self._chart_canvas.yview('moveto',
|
||
|
|
(y-dy)/self._chart_height)
|
||
|
|
|
||
|
|
def _draw_edge(self, edge, lvl):
|
||
|
|
"""
|
||
|
|
Draw a single edge on the ChartView.
|
||
|
|
"""
|
||
|
|
c = self._chart_canvas
|
||
|
|
|
||
|
|
# Draw the arrow.
|
||
|
|
x1 = (edge.start() * self._unitsize + ChartView._MARGIN)
|
||
|
|
x2 = (edge.end() * self._unitsize + ChartView._MARGIN)
|
||
|
|
if x2 == x1: x2 += max(4, self._unitsize/5)
|
||
|
|
y = (lvl+1) * self._chart_level_size
|
||
|
|
linetag = c.create_line(x1, y, x2, y, arrow='last', width=3)
|
||
|
|
|
||
|
|
# Draw a label for the edge.
|
||
|
|
if isinstance(edge, TreeEdge):
|
||
|
|
rhs = []
|
||
|
|
for elt in edge.rhs():
|
||
|
|
if isinstance(elt, Nonterminal):
|
||
|
|
rhs.append(str(elt.symbol()))
|
||
|
|
else:
|
||
|
|
rhs.append(repr(elt))
|
||
|
|
pos = edge.dot()
|
||
|
|
else:
|
||
|
|
rhs = []
|
||
|
|
pos = 0
|
||
|
|
|
||
|
|
rhs1 = " ".join(rhs[:pos])
|
||
|
|
rhs2 = " ".join(rhs[pos:])
|
||
|
|
rhstag1 = c.create_text(x1+3, y, text=rhs1,
|
||
|
|
font=self._font,
|
||
|
|
anchor='nw')
|
||
|
|
dotx = c.bbox(rhstag1)[2] + 6
|
||
|
|
doty = (c.bbox(rhstag1)[1]+c.bbox(rhstag1)[3])/2
|
||
|
|
dottag = c.create_oval(dotx-2, doty-2, dotx+2, doty+2)
|
||
|
|
rhstag2 = c.create_text(dotx+6, y, text=rhs2,
|
||
|
|
font=self._font,
|
||
|
|
anchor='nw')
|
||
|
|
lhstag = c.create_text((x1+x2)/2, y, text=str(edge.lhs()),
|
||
|
|
anchor='s',
|
||
|
|
font=self._boldfont)
|
||
|
|
|
||
|
|
# Keep track of the edge's tags.
|
||
|
|
self._edgetags[edge] = (linetag, rhstag1,
|
||
|
|
dottag, rhstag2, lhstag)
|
||
|
|
|
||
|
|
# Register a callback for clicking on the edge.
|
||
|
|
def cb(event, self=self, edge=edge):
|
||
|
|
self._fire_callbacks('select', edge)
|
||
|
|
c.tag_bind(rhstag1, '<Button-1>', cb)
|
||
|
|
c.tag_bind(rhstag2, '<Button-1>', cb)
|
||
|
|
c.tag_bind(linetag, '<Button-1>', cb)
|
||
|
|
c.tag_bind(dottag, '<Button-1>', cb)
|
||
|
|
c.tag_bind(lhstag, '<Button-1>', cb)
|
||
|
|
|
||
|
|
self._color_edge(edge)
|
||
|
|
|
||
|
|
def _color_edge(self, edge, linecolor=None, textcolor=None):
|
||
|
|
"""
|
||
|
|
Color in an edge with the given colors.
|
||
|
|
If no colors are specified, use intelligent defaults
|
||
|
|
(dependent on selection, etc.)
|
||
|
|
"""
|
||
|
|
if edge not in self._edgetags: return
|
||
|
|
c = self._chart_canvas
|
||
|
|
|
||
|
|
if linecolor is not None and textcolor is not None:
|
||
|
|
if edge in self._marks:
|
||
|
|
linecolor = self._marks[edge]
|
||
|
|
tags = self._edgetags[edge]
|
||
|
|
c.itemconfig(tags[0], fill=linecolor)
|
||
|
|
c.itemconfig(tags[1], fill=textcolor)
|
||
|
|
c.itemconfig(tags[2], fill=textcolor,
|
||
|
|
outline=textcolor)
|
||
|
|
c.itemconfig(tags[3], fill=textcolor)
|
||
|
|
c.itemconfig(tags[4], fill=textcolor)
|
||
|
|
return
|
||
|
|
else:
|
||
|
|
N = self._chart.num_leaves()
|
||
|
|
if edge in self._marks:
|
||
|
|
self._color_edge(self._marks[edge])
|
||
|
|
if (edge.is_complete() and edge.span() == (0, N)):
|
||
|
|
self._color_edge(edge, '#084', '#042')
|
||
|
|
elif isinstance(edge, LeafEdge):
|
||
|
|
self._color_edge(edge, '#48c', '#246')
|
||
|
|
else:
|
||
|
|
self._color_edge(edge, '#00f', '#008')
|
||
|
|
|
||
|
|
def mark_edge(self, edge, mark='#0df'):
|
||
|
|
"""
|
||
|
|
Mark an edge
|
||
|
|
"""
|
||
|
|
self._marks[edge] = mark
|
||
|
|
self._color_edge(edge)
|
||
|
|
|
||
|
|
def unmark_edge(self, edge=None):
|
||
|
|
"""
|
||
|
|
Unmark an edge (or all edges)
|
||
|
|
"""
|
||
|
|
if edge is None:
|
||
|
|
old_marked_edges = list(self._marks.keys())
|
||
|
|
self._marks = {}
|
||
|
|
for edge in old_marked_edges:
|
||
|
|
self._color_edge(edge)
|
||
|
|
else:
|
||
|
|
del self._marks[edge]
|
||
|
|
self._color_edge(edge)
|
||
|
|
|
||
|
|
def markonly_edge(self, edge, mark='#0df'):
|
||
|
|
self.unmark_edge()
|
||
|
|
self.mark_edge(edge, mark)
|
||
|
|
|
||
|
|
def _analyze(self):
|
||
|
|
"""
|
||
|
|
Analyze the sentence string, to figure out how big a unit needs
|
||
|
|
to be, How big the tree should be, etc.
|
||
|
|
"""
|
||
|
|
# Figure out the text height and the unit size.
|
||
|
|
unitsize = 70 # min unitsize
|
||
|
|
text_height = 0
|
||
|
|
c = self._chart_canvas
|
||
|
|
|
||
|
|
# Check against all tokens
|
||
|
|
for leaf in self._chart.leaves():
|
||
|
|
tag = c.create_text(0,0, text=repr(leaf),
|
||
|
|
font=self._font,
|
||
|
|
anchor='nw', justify='left')
|
||
|
|
bbox = c.bbox(tag)
|
||
|
|
c.delete(tag)
|
||
|
|
width = bbox[2] + ChartView._LEAF_SPACING
|
||
|
|
unitsize = max(width, unitsize)
|
||
|
|
text_height = max(text_height, bbox[3] - bbox[1])
|
||
|
|
|
||
|
|
self._unitsize = unitsize
|
||
|
|
self._text_height = text_height
|
||
|
|
self._sentence_height = (self._text_height +
|
||
|
|
2*ChartView._MARGIN)
|
||
|
|
|
||
|
|
# Check against edges.
|
||
|
|
for edge in self._chart.edges():
|
||
|
|
self._analyze_edge(edge)
|
||
|
|
|
||
|
|
# Size of chart levels
|
||
|
|
self._chart_level_size = self._text_height * 2
|
||
|
|
|
||
|
|
# Default tree size..
|
||
|
|
self._tree_height = (3 * (ChartView._TREE_LEVEL_SIZE +
|
||
|
|
self._text_height))
|
||
|
|
|
||
|
|
# Resize the scrollregions.
|
||
|
|
self._resize()
|
||
|
|
|
||
|
|
def _resize(self):
|
||
|
|
"""
|
||
|
|
Update the scroll-regions for each canvas. This ensures that
|
||
|
|
everything is within a scroll-region, so the user can use the
|
||
|
|
scrollbars to view the entire display. This does *not*
|
||
|
|
resize the window.
|
||
|
|
"""
|
||
|
|
c = self._chart_canvas
|
||
|
|
|
||
|
|
# Reset the chart scroll region
|
||
|
|
width = ( self._chart.num_leaves() * self._unitsize +
|
||
|
|
ChartView._MARGIN * 2 )
|
||
|
|
|
||
|
|
levels = len(self._edgelevels)
|
||
|
|
self._chart_height = (levels+2)*self._chart_level_size
|
||
|
|
c['scrollregion']=(0,0,width,self._chart_height)
|
||
|
|
|
||
|
|
# Reset the tree scroll region
|
||
|
|
if self._tree_canvas:
|
||
|
|
self._tree_canvas['scrollregion'] = (0, 0, width,
|
||
|
|
self._tree_height)
|
||
|
|
|
||
|
|
def _draw_loclines(self):
|
||
|
|
"""
|
||
|
|
Draw location lines. These are vertical gridlines used to
|
||
|
|
show where each location unit is.
|
||
|
|
"""
|
||
|
|
BOTTOM = 50000
|
||
|
|
c1 = self._tree_canvas
|
||
|
|
c2 = self._sentence_canvas
|
||
|
|
c3 = self._chart_canvas
|
||
|
|
margin = ChartView._MARGIN
|
||
|
|
self._loclines = []
|
||
|
|
for i in range(0, self._chart.num_leaves()+1):
|
||
|
|
x = i*self._unitsize + margin
|
||
|
|
|
||
|
|
if c1:
|
||
|
|
t1=c1.create_line(x, 0, x, BOTTOM)
|
||
|
|
c1.tag_lower(t1)
|
||
|
|
if c2:
|
||
|
|
t2=c2.create_line(x, 0, x, self._sentence_height)
|
||
|
|
c2.tag_lower(t2)
|
||
|
|
t3=c3.create_line(x, 0, x, BOTTOM)
|
||
|
|
c3.tag_lower(t3)
|
||
|
|
t4=c3.create_text(x+2, 0, text=repr(i), anchor='nw',
|
||
|
|
font=self._font)
|
||
|
|
c3.tag_lower(t4)
|
||
|
|
#if i % 4 == 0:
|
||
|
|
# if c1: c1.itemconfig(t1, width=2, fill='gray60')
|
||
|
|
# if c2: c2.itemconfig(t2, width=2, fill='gray60')
|
||
|
|
# c3.itemconfig(t3, width=2, fill='gray60')
|
||
|
|
if i % 2 == 0:
|
||
|
|
if c1: c1.itemconfig(t1, fill='gray60')
|
||
|
|
if c2: c2.itemconfig(t2, fill='gray60')
|
||
|
|
c3.itemconfig(t3, fill='gray60')
|
||
|
|
else:
|
||
|
|
if c1: c1.itemconfig(t1, fill='gray80')
|
||
|
|
if c2: c2.itemconfig(t2, fill='gray80')
|
||
|
|
c3.itemconfig(t3, fill='gray80')
|
||
|
|
|
||
|
|
def _draw_sentence(self):
|
||
|
|
"""Draw the sentence string."""
|
||
|
|
if self._chart.num_leaves() == 0: return
|
||
|
|
c = self._sentence_canvas
|
||
|
|
margin = ChartView._MARGIN
|
||
|
|
y = ChartView._MARGIN
|
||
|
|
|
||
|
|
for i, leaf in enumerate(self._chart.leaves()):
|
||
|
|
x1 = i * self._unitsize + margin
|
||
|
|
x2 = x1 + self._unitsize
|
||
|
|
x = (x1+x2)/2
|
||
|
|
tag = c.create_text(x, y, text=repr(leaf),
|
||
|
|
font=self._font,
|
||
|
|
anchor='n', justify='left')
|
||
|
|
bbox = c.bbox(tag)
|
||
|
|
rt=c.create_rectangle(x1+2, bbox[1]-(ChartView._LEAF_SPACING/2),
|
||
|
|
x2-2, bbox[3]+(ChartView._LEAF_SPACING/2),
|
||
|
|
fill='#f0f0f0', outline='#f0f0f0')
|
||
|
|
c.tag_lower(rt)
|
||
|
|
|
||
|
|
def erase_tree(self):
|
||
|
|
for tag in self._tree_tags: self._tree_canvas.delete(tag)
|
||
|
|
self._treetoks = []
|
||
|
|
self._treetoks_edge = None
|
||
|
|
self._treetoks_index = 0
|
||
|
|
|
||
|
|
def draw_tree(self, edge=None):
|
||
|
|
if edge is None and self._treetoks_edge is None: return
|
||
|
|
if edge is None: edge = self._treetoks_edge
|
||
|
|
|
||
|
|
# If it's a new edge, then get a new list of treetoks.
|
||
|
|
if self._treetoks_edge != edge:
|
||
|
|
self._treetoks = [t for t in self._chart.trees(edge)
|
||
|
|
if isinstance(t, Tree)]
|
||
|
|
self._treetoks_edge = edge
|
||
|
|
self._treetoks_index = 0
|
||
|
|
|
||
|
|
# Make sure there's something to draw.
|
||
|
|
if len(self._treetoks) == 0: return
|
||
|
|
|
||
|
|
# Erase the old tree.
|
||
|
|
for tag in self._tree_tags: self._tree_canvas.delete(tag)
|
||
|
|
|
||
|
|
# Draw the new tree.
|
||
|
|
tree = self._treetoks[self._treetoks_index]
|
||
|
|
self._draw_treetok(tree, edge.start())
|
||
|
|
|
||
|
|
# Show how many trees are available for the edge.
|
||
|
|
self._draw_treecycle()
|
||
|
|
|
||
|
|
# Update the scroll region.
|
||
|
|
w = self._chart.num_leaves()*self._unitsize+2*ChartView._MARGIN
|
||
|
|
h = tree.height() * (ChartView._TREE_LEVEL_SIZE+self._text_height)
|
||
|
|
self._tree_canvas['scrollregion'] = (0, 0, w, h)
|
||
|
|
|
||
|
|
def cycle_tree(self):
|
||
|
|
self._treetoks_index = (self._treetoks_index+1)%len(self._treetoks)
|
||
|
|
self.draw_tree(self._treetoks_edge)
|
||
|
|
|
||
|
|
def _draw_treecycle(self):
|
||
|
|
if len(self._treetoks) <= 1: return
|
||
|
|
|
||
|
|
# Draw the label.
|
||
|
|
label = '%d Trees' % len(self._treetoks)
|
||
|
|
c = self._tree_canvas
|
||
|
|
margin = ChartView._MARGIN
|
||
|
|
right = self._chart.num_leaves()*self._unitsize+margin-2
|
||
|
|
tag = c.create_text(right, 2, anchor='ne', text=label,
|
||
|
|
font=self._boldfont)
|
||
|
|
self._tree_tags.append(tag)
|
||
|
|
_, _, _, y = c.bbox(tag)
|
||
|
|
|
||
|
|
# Draw the triangles.
|
||
|
|
for i in range(len(self._treetoks)):
|
||
|
|
x = right - 20*(len(self._treetoks)-i-1)
|
||
|
|
if i == self._treetoks_index: fill = '#084'
|
||
|
|
else: fill = '#fff'
|
||
|
|
tag = c.create_polygon(x, y+10, x-5, y, x-10, y+10,
|
||
|
|
fill=fill, outline='black')
|
||
|
|
self._tree_tags.append(tag)
|
||
|
|
|
||
|
|
# Set up a callback: show the tree if they click on its
|
||
|
|
# triangle.
|
||
|
|
def cb(event, self=self, i=i):
|
||
|
|
self._treetoks_index = i
|
||
|
|
self.draw_tree()
|
||
|
|
c.tag_bind(tag, '<Button-1>', cb)
|
||
|
|
|
||
|
|
def _draw_treetok(self, treetok, index, depth=0):
|
||
|
|
"""
|
||
|
|
:param index: The index of the first leaf in the tree.
|
||
|
|
:return: The index of the first leaf after the tree.
|
||
|
|
"""
|
||
|
|
c = self._tree_canvas
|
||
|
|
margin = ChartView._MARGIN
|
||
|
|
|
||
|
|
# Draw the children
|
||
|
|
child_xs = []
|
||
|
|
for child in treetok:
|
||
|
|
if isinstance(child, Tree):
|
||
|
|
child_x, index = self._draw_treetok(child, index, depth+1)
|
||
|
|
child_xs.append(child_x)
|
||
|
|
else:
|
||
|
|
child_xs.append((2*index+1)*self._unitsize/2 + margin)
|
||
|
|
index += 1
|
||
|
|
|
||
|
|
# If we have children, then get the node's x by averaging their
|
||
|
|
# node x's. Otherwise, make room for ourselves.
|
||
|
|
if child_xs:
|
||
|
|
nodex = sum(child_xs)/len(child_xs)
|
||
|
|
else:
|
||
|
|
# [XX] breaks for null productions.
|
||
|
|
nodex = (2*index+1)*self._unitsize/2 + margin
|
||
|
|
index += 1
|
||
|
|
|
||
|
|
# Draw the node
|
||
|
|
nodey = depth * (ChartView._TREE_LEVEL_SIZE + self._text_height)
|
||
|
|
tag = c.create_text(nodex, nodey, anchor='n', justify='center',
|
||
|
|
text=str(treetok.label()), fill='#042',
|
||
|
|
font=self._boldfont)
|
||
|
|
self._tree_tags.append(tag)
|
||
|
|
|
||
|
|
# Draw lines to the children.
|
||
|
|
childy = nodey + ChartView._TREE_LEVEL_SIZE + self._text_height
|
||
|
|
for childx, child in zip(child_xs, treetok):
|
||
|
|
if isinstance(child, Tree) and child:
|
||
|
|
# A "real" tree token:
|
||
|
|
tag = c.create_line(nodex, nodey + self._text_height,
|
||
|
|
childx, childy, width=2, fill='#084')
|
||
|
|
self._tree_tags.append(tag)
|
||
|
|
if isinstance(child, Tree) and not child:
|
||
|
|
# An unexpanded tree token:
|
||
|
|
tag = c.create_line(nodex, nodey + self._text_height,
|
||
|
|
childx, childy, width=2,
|
||
|
|
fill='#048', dash='2 3')
|
||
|
|
self._tree_tags.append(tag)
|
||
|
|
if not isinstance(child, Tree):
|
||
|
|
# A leaf:
|
||
|
|
tag = c.create_line(nodex, nodey + self._text_height,
|
||
|
|
childx, 10000, width=2, fill='#084')
|
||
|
|
self._tree_tags.append(tag)
|
||
|
|
|
||
|
|
return nodex, index
|
||
|
|
|
||
|
|
def draw(self):
|
||
|
|
"""
|
||
|
|
Draw everything (from scratch).
|
||
|
|
"""
|
||
|
|
if self._tree_canvas:
|
||
|
|
self._tree_canvas.delete('all')
|
||
|
|
self.draw_tree()
|
||
|
|
|
||
|
|
if self._sentence_canvas:
|
||
|
|
self._sentence_canvas.delete('all')
|
||
|
|
self._draw_sentence()
|
||
|
|
|
||
|
|
self._chart_canvas.delete('all')
|
||
|
|
self._edgetags = {}
|
||
|
|
|
||
|
|
# Redraw any edges we erased.
|
||
|
|
for lvl in range(len(self._edgelevels)):
|
||
|
|
for edge in self._edgelevels[lvl]:
|
||
|
|
self._draw_edge(edge, lvl)
|
||
|
|
|
||
|
|
for edge in self._chart:
|
||
|
|
self._add_edge(edge)
|
||
|
|
|
||
|
|
self._draw_loclines()
|
||
|
|
|
||
|
|
def add_callback(self, event, func):
|
||
|
|
self._callbacks.setdefault(event,{})[func] = 1
|
||
|
|
|
||
|
|
def remove_callback(self, event, func=None):
|
||
|
|
if func is None: del self._callbacks[event]
|
||
|
|
else:
|
||
|
|
try: del self._callbacks[event][func]
|
||
|
|
except: pass
|
||
|
|
|
||
|
|
def _fire_callbacks(self, event, *args):
|
||
|
|
if event not in self._callbacks: return
|
||
|
|
for cb_func in list(self._callbacks[event].keys()): cb_func(*args)
|
||
|
|
|
||
|
|
#######################################################################
|
||
|
|
# Edge Rules
|
||
|
|
#######################################################################
|
||
|
|
# These version of the chart rules only apply to a specific edge.
|
||
|
|
# This lets the user select an edge, and then apply a rule.
|
||
|
|
|
||
|
|
class EdgeRule(object):
|
||
|
|
"""
|
||
|
|
To create an edge rule, make an empty base class that uses
|
||
|
|
EdgeRule as the first base class, and the basic rule as the
|
||
|
|
second base class. (Order matters!)
|
||
|
|
"""
|
||
|
|
def __init__(self, edge):
|
||
|
|
super = self.__class__.__bases__[1]
|
||
|
|
self._edge = edge
|
||
|
|
self.NUM_EDGES = super.NUM_EDGES-1
|
||
|
|
def apply(self, chart, grammar, *edges):
|
||
|
|
super = self.__class__.__bases__[1]
|
||
|
|
edges += (self._edge,)
|
||
|
|
for e in super.apply(self, chart, grammar, *edges): yield e
|
||
|
|
def __str__(self):
|
||
|
|
super = self.__class__.__bases__[1]
|
||
|
|
return super.__str__(self)
|
||
|
|
|
||
|
|
class TopDownPredictEdgeRule(EdgeRule, TopDownPredictRule):
|
||
|
|
pass
|
||
|
|
class BottomUpEdgeRule(EdgeRule, BottomUpPredictRule):
|
||
|
|
pass
|
||
|
|
class BottomUpLeftCornerEdgeRule(EdgeRule, BottomUpPredictCombineRule):
|
||
|
|
pass
|
||
|
|
class FundamentalEdgeRule(EdgeRule, SingleEdgeFundamentalRule):
|
||
|
|
pass
|
||
|
|
|
||
|
|
#######################################################################
|
||
|
|
# Chart Parser Application
|
||
|
|
#######################################################################
|
||
|
|
|
||
|
|
class ChartParserApp(object):
|
||
|
|
def __init__(self, grammar, tokens, title='Chart Parser Application'):
|
||
|
|
# Initialize the parser
|
||
|
|
self._init_parser(grammar, tokens)
|
||
|
|
|
||
|
|
self._root = None
|
||
|
|
try:
|
||
|
|
# Create the root window.
|
||
|
|
self._root = Tk()
|
||
|
|
self._root.title(title)
|
||
|
|
self._root.bind('<Control-q>', self.destroy)
|
||
|
|
|
||
|
|
# Set up some frames.
|
||
|
|
frame3 = Frame(self._root)
|
||
|
|
frame2 = Frame(self._root)
|
||
|
|
frame1 = Frame(self._root)
|
||
|
|
frame3.pack(side='bottom', fill='none')
|
||
|
|
frame2.pack(side='bottom', fill='x')
|
||
|
|
frame1.pack(side='bottom', fill='both', expand=1)
|
||
|
|
|
||
|
|
self._init_fonts(self._root)
|
||
|
|
self._init_animation()
|
||
|
|
self._init_chartview(frame1)
|
||
|
|
self._init_rulelabel(frame2)
|
||
|
|
self._init_buttons(frame3)
|
||
|
|
self._init_menubar()
|
||
|
|
|
||
|
|
self._matrix = None
|
||
|
|
self._results = None
|
||
|
|
|
||
|
|
# Set up keyboard bindings.
|
||
|
|
self._init_bindings()
|
||
|
|
|
||
|
|
except:
|
||
|
|
print('Error creating Tree View')
|
||
|
|
self.destroy()
|
||
|
|
raise
|
||
|
|
|
||
|
|
def destroy(self, *args):
|
||
|
|
if self._root is None: return
|
||
|
|
self._root.destroy()
|
||
|
|
self._root = None
|
||
|
|
|
||
|
|
def mainloop(self, *args, **kwargs):
|
||
|
|
"""
|
||
|
|
Enter the Tkinter mainloop. This function must be called if
|
||
|
|
this demo is created from a non-interactive program (e.g.
|
||
|
|
from a secript); otherwise, the demo will close as soon as
|
||
|
|
the script completes.
|
||
|
|
"""
|
||
|
|
if in_idle(): return
|
||
|
|
self._root.mainloop(*args, **kwargs)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Initialization Helpers
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def _init_parser(self, grammar, tokens):
|
||
|
|
self._grammar = grammar
|
||
|
|
self._tokens = tokens
|
||
|
|
self._reset_parser()
|
||
|
|
|
||
|
|
def _reset_parser(self):
|
||
|
|
self._cp = SteppingChartParser(self._grammar)
|
||
|
|
self._cp.initialize(self._tokens)
|
||
|
|
self._chart = self._cp.chart()
|
||
|
|
|
||
|
|
# Insert LeafEdges before the parsing starts.
|
||
|
|
for _new_edge in LeafInitRule().apply(self._chart, self._grammar):
|
||
|
|
pass
|
||
|
|
|
||
|
|
# The step iterator -- use this to generate new edges
|
||
|
|
self._cpstep = self._cp.step()
|
||
|
|
|
||
|
|
# The currently selected edge
|
||
|
|
self._selection = None
|
||
|
|
|
||
|
|
def _init_fonts(self, root):
|
||
|
|
# See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
|
||
|
|
self._sysfont = Font(font=Button()["font"])
|
||
|
|
root.option_add("*Font", self._sysfont)
|
||
|
|
|
||
|
|
# TWhat's our font size (default=same as sysfont)
|
||
|
|
self._size = IntVar(root)
|
||
|
|
self._size.set(self._sysfont.cget('size'))
|
||
|
|
|
||
|
|
self._boldfont = Font(family='helvetica', weight='bold',
|
||
|
|
size=self._size.get())
|
||
|
|
self._font = Font(family='helvetica',
|
||
|
|
size=self._size.get())
|
||
|
|
|
||
|
|
def _init_animation(self):
|
||
|
|
# Are we stepping? (default=yes)
|
||
|
|
self._step = IntVar(self._root)
|
||
|
|
self._step.set(1)
|
||
|
|
|
||
|
|
# What's our animation speed (default=fast)
|
||
|
|
self._animate = IntVar(self._root)
|
||
|
|
self._animate.set(3) # Default speed = fast
|
||
|
|
|
||
|
|
# Are we currently animating?
|
||
|
|
self._animating = 0
|
||
|
|
|
||
|
|
def _init_chartview(self, parent):
|
||
|
|
self._cv = ChartView(self._chart, parent,
|
||
|
|
draw_tree=1, draw_sentence=1)
|
||
|
|
self._cv.add_callback('select', self._click_cv_edge)
|
||
|
|
|
||
|
|
def _init_rulelabel(self, parent):
|
||
|
|
ruletxt = 'Last edge generated by:'
|
||
|
|
|
||
|
|
self._rulelabel1 = Label(parent,text=ruletxt,
|
||
|
|
font=self._boldfont)
|
||
|
|
self._rulelabel2 = Label(parent, width=40,
|
||
|
|
relief='groove', anchor='w',
|
||
|
|
font=self._boldfont)
|
||
|
|
self._rulelabel1.pack(side='left')
|
||
|
|
self._rulelabel2.pack(side='left')
|
||
|
|
step = Checkbutton(parent, variable=self._step,
|
||
|
|
text='Step')
|
||
|
|
step.pack(side='right')
|
||
|
|
|
||
|
|
def _init_buttons(self, parent):
|
||
|
|
frame1 = Frame(parent)
|
||
|
|
frame2 = Frame(parent)
|
||
|
|
frame1.pack(side='bottom', fill='x')
|
||
|
|
frame2.pack(side='top', fill='none')
|
||
|
|
|
||
|
|
Button(frame1, text='Reset\nParser',
|
||
|
|
background='#90c0d0', foreground='black',
|
||
|
|
command=self.reset).pack(side='right')
|
||
|
|
# Button(frame1, text='Pause',
|
||
|
|
# background='#90c0d0', foreground='black',
|
||
|
|
# command=self.pause).pack(side='left')
|
||
|
|
|
||
|
|
Button(frame1, text='Top Down\nStrategy',
|
||
|
|
background='#90c0d0', foreground='black',
|
||
|
|
command=self.top_down_strategy).pack(side='left')
|
||
|
|
Button(frame1, text='Bottom Up\nStrategy',
|
||
|
|
background='#90c0d0', foreground='black',
|
||
|
|
command=self.bottom_up_strategy).pack(side='left')
|
||
|
|
Button(frame1, text='Bottom Up\nLeft-Corner Strategy',
|
||
|
|
background='#90c0d0', foreground='black',
|
||
|
|
command=self.bottom_up_leftcorner_strategy).pack(side='left')
|
||
|
|
|
||
|
|
Button(frame2, text='Top Down Init\nRule',
|
||
|
|
background='#90f090', foreground='black',
|
||
|
|
command=self.top_down_init).pack(side='left')
|
||
|
|
Button(frame2, text='Top Down Predict\nRule',
|
||
|
|
background='#90f090', foreground='black',
|
||
|
|
command=self.top_down_predict).pack(side='left')
|
||
|
|
Frame(frame2, width=20).pack(side='left')
|
||
|
|
|
||
|
|
Button(frame2, text='Bottom Up Predict\nRule',
|
||
|
|
background='#90f090', foreground='black',
|
||
|
|
command=self.bottom_up).pack(side='left')
|
||
|
|
Frame(frame2, width=20).pack(side='left')
|
||
|
|
|
||
|
|
Button(frame2, text='Bottom Up Left-Corner\nPredict Rule',
|
||
|
|
background='#90f090', foreground='black',
|
||
|
|
command=self.bottom_up_leftcorner).pack(side='left')
|
||
|
|
Frame(frame2, width=20).pack(side='left')
|
||
|
|
|
||
|
|
Button(frame2, text='Fundamental\nRule',
|
||
|
|
background='#90f090', foreground='black',
|
||
|
|
command=self.fundamental).pack(side='left')
|
||
|
|
|
||
|
|
def _init_bindings(self):
|
||
|
|
self._root.bind('<Up>', self._cv.scroll_up)
|
||
|
|
self._root.bind('<Down>', self._cv.scroll_down)
|
||
|
|
self._root.bind('<Prior>', self._cv.page_up)
|
||
|
|
self._root.bind('<Next>', self._cv.page_down)
|
||
|
|
self._root.bind('<Control-q>', self.destroy)
|
||
|
|
self._root.bind('<Control-x>', self.destroy)
|
||
|
|
self._root.bind('<F1>', self.help)
|
||
|
|
|
||
|
|
self._root.bind('<Control-s>', self.save_chart)
|
||
|
|
self._root.bind('<Control-o>', self.load_chart)
|
||
|
|
self._root.bind('<Control-r>', self.reset)
|
||
|
|
|
||
|
|
self._root.bind('t', self.top_down_strategy)
|
||
|
|
self._root.bind('b', self.bottom_up_strategy)
|
||
|
|
self._root.bind('c', self.bottom_up_leftcorner_strategy)
|
||
|
|
self._root.bind('<space>', self._stop_animation)
|
||
|
|
|
||
|
|
self._root.bind('<Control-g>', self.edit_grammar)
|
||
|
|
self._root.bind('<Control-t>', self.edit_sentence)
|
||
|
|
|
||
|
|
# Animation speed control
|
||
|
|
self._root.bind('-', lambda e,a=self._animate:a.set(1))
|
||
|
|
self._root.bind('=', lambda e,a=self._animate:a.set(2))
|
||
|
|
self._root.bind('+', lambda e,a=self._animate:a.set(3))
|
||
|
|
|
||
|
|
# Step control
|
||
|
|
self._root.bind('s', lambda e,s=self._step:s.set(not s.get()))
|
||
|
|
|
||
|
|
def _init_menubar(self):
|
||
|
|
menubar = Menu(self._root)
|
||
|
|
|
||
|
|
filemenu = Menu(menubar, tearoff=0)
|
||
|
|
filemenu.add_command(label='Save Chart', underline=0,
|
||
|
|
command=self.save_chart, accelerator='Ctrl-s')
|
||
|
|
filemenu.add_command(label='Load Chart', underline=0,
|
||
|
|
command=self.load_chart, accelerator='Ctrl-o')
|
||
|
|
filemenu.add_command(label='Reset Chart', underline=0,
|
||
|
|
command=self.reset, accelerator='Ctrl-r')
|
||
|
|
filemenu.add_separator()
|
||
|
|
filemenu.add_command(label='Save Grammar',
|
||
|
|
command=self.save_grammar)
|
||
|
|
filemenu.add_command(label='Load Grammar',
|
||
|
|
command=self.load_grammar)
|
||
|
|
filemenu.add_separator()
|
||
|
|
filemenu.add_command(label='Exit', underline=1,
|
||
|
|
command=self.destroy, accelerator='Ctrl-x')
|
||
|
|
menubar.add_cascade(label='File', underline=0, menu=filemenu)
|
||
|
|
|
||
|
|
editmenu = Menu(menubar, tearoff=0)
|
||
|
|
editmenu.add_command(label='Edit Grammar', underline=5,
|
||
|
|
command=self.edit_grammar,
|
||
|
|
accelerator='Ctrl-g')
|
||
|
|
editmenu.add_command(label='Edit Text', underline=5,
|
||
|
|
command=self.edit_sentence,
|
||
|
|
accelerator='Ctrl-t')
|
||
|
|
menubar.add_cascade(label='Edit', underline=0, menu=editmenu)
|
||
|
|
|
||
|
|
viewmenu = Menu(menubar, tearoff=0)
|
||
|
|
viewmenu.add_command(label='Chart Matrix', underline=6,
|
||
|
|
command=self.view_matrix)
|
||
|
|
viewmenu.add_command(label='Results', underline=0,
|
||
|
|
command=self.view_results)
|
||
|
|
menubar.add_cascade(label='View', underline=0, menu=viewmenu)
|
||
|
|
|
||
|
|
rulemenu = Menu(menubar, tearoff=0)
|
||
|
|
rulemenu.add_command(label='Top Down Strategy', underline=0,
|
||
|
|
command=self.top_down_strategy,
|
||
|
|
accelerator='t')
|
||
|
|
rulemenu.add_command(label='Bottom Up Strategy', underline=0,
|
||
|
|
command=self.bottom_up_strategy,
|
||
|
|
accelerator='b')
|
||
|
|
rulemenu.add_command(label='Bottom Up Left-Corner Strategy', underline=0,
|
||
|
|
command=self.bottom_up_leftcorner_strategy,
|
||
|
|
accelerator='c')
|
||
|
|
rulemenu.add_separator()
|
||
|
|
rulemenu.add_command(label='Bottom Up Rule',
|
||
|
|
command=self.bottom_up)
|
||
|
|
rulemenu.add_command(label='Bottom Up Left-Corner Rule',
|
||
|
|
command=self.bottom_up_leftcorner)
|
||
|
|
rulemenu.add_command(label='Top Down Init Rule',
|
||
|
|
command=self.top_down_init)
|
||
|
|
rulemenu.add_command(label='Top Down Predict Rule',
|
||
|
|
command=self.top_down_predict)
|
||
|
|
rulemenu.add_command(label='Fundamental Rule',
|
||
|
|
command=self.fundamental)
|
||
|
|
menubar.add_cascade(label='Apply', underline=0, menu=rulemenu)
|
||
|
|
|
||
|
|
animatemenu = Menu(menubar, tearoff=0)
|
||
|
|
animatemenu.add_checkbutton(label="Step", underline=0,
|
||
|
|
variable=self._step,
|
||
|
|
accelerator='s')
|
||
|
|
animatemenu.add_separator()
|
||
|
|
animatemenu.add_radiobutton(label="No Animation", underline=0,
|
||
|
|
variable=self._animate, value=0)
|
||
|
|
animatemenu.add_radiobutton(label="Slow Animation", underline=0,
|
||
|
|
variable=self._animate, value=1,
|
||
|
|
accelerator='-')
|
||
|
|
animatemenu.add_radiobutton(label="Normal Animation", underline=0,
|
||
|
|
variable=self._animate, value=2,
|
||
|
|
accelerator='=')
|
||
|
|
animatemenu.add_radiobutton(label="Fast Animation", underline=0,
|
||
|
|
variable=self._animate, value=3,
|
||
|
|
accelerator='+')
|
||
|
|
menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
|
||
|
|
|
||
|
|
zoommenu = Menu(menubar, tearoff=0)
|
||
|
|
zoommenu.add_radiobutton(label='Tiny', variable=self._size,
|
||
|
|
underline=0, value=10, command=self.resize)
|
||
|
|
zoommenu.add_radiobutton(label='Small', variable=self._size,
|
||
|
|
underline=0, value=12, command=self.resize)
|
||
|
|
zoommenu.add_radiobutton(label='Medium', variable=self._size,
|
||
|
|
underline=0, value=14, command=self.resize)
|
||
|
|
zoommenu.add_radiobutton(label='Large', variable=self._size,
|
||
|
|
underline=0, value=18, command=self.resize)
|
||
|
|
zoommenu.add_radiobutton(label='Huge', variable=self._size,
|
||
|
|
underline=0, value=24, command=self.resize)
|
||
|
|
menubar.add_cascade(label='Zoom', underline=0, menu=zoommenu)
|
||
|
|
|
||
|
|
helpmenu = Menu(menubar, tearoff=0)
|
||
|
|
helpmenu.add_command(label='About', underline=0,
|
||
|
|
command=self.about)
|
||
|
|
helpmenu.add_command(label='Instructions', underline=0,
|
||
|
|
command=self.help, accelerator='F1')
|
||
|
|
menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
|
||
|
|
|
||
|
|
self._root.config(menu=menubar)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Selection Handling
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def _click_cv_edge(self, edge):
|
||
|
|
if edge != self._selection:
|
||
|
|
# Clicking on a new edge selects it.
|
||
|
|
self._select_edge(edge)
|
||
|
|
else:
|
||
|
|
# Repeated clicks on one edge cycle its trees.
|
||
|
|
self._cv.cycle_tree()
|
||
|
|
# [XX] this can get confused if animation is running
|
||
|
|
# faster than the callbacks...
|
||
|
|
|
||
|
|
def _select_matrix_edge(self, edge):
|
||
|
|
self._select_edge(edge)
|
||
|
|
self._cv.view_edge(edge)
|
||
|
|
|
||
|
|
def _select_edge(self, edge):
|
||
|
|
self._selection = edge
|
||
|
|
# Update the chart view.
|
||
|
|
self._cv.markonly_edge(edge, '#f00')
|
||
|
|
self._cv.draw_tree(edge)
|
||
|
|
# Update the matrix view.
|
||
|
|
if self._matrix: self._matrix.markonly_edge(edge)
|
||
|
|
if self._matrix: self._matrix.view_edge(edge)
|
||
|
|
|
||
|
|
def _deselect_edge(self):
|
||
|
|
self._selection = None
|
||
|
|
# Update the chart view.
|
||
|
|
self._cv.unmark_edge()
|
||
|
|
self._cv.erase_tree()
|
||
|
|
# Update the matrix view
|
||
|
|
if self._matrix: self._matrix.unmark_edge()
|
||
|
|
|
||
|
|
def _show_new_edge(self, edge):
|
||
|
|
self._display_rule(self._cp.current_chartrule())
|
||
|
|
# Update the chart view.
|
||
|
|
self._cv.update()
|
||
|
|
self._cv.draw_tree(edge)
|
||
|
|
self._cv.markonly_edge(edge, '#0df')
|
||
|
|
self._cv.view_edge(edge)
|
||
|
|
# Update the matrix view.
|
||
|
|
if self._matrix: self._matrix.update()
|
||
|
|
if self._matrix: self._matrix.markonly_edge(edge)
|
||
|
|
if self._matrix: self._matrix.view_edge(edge)
|
||
|
|
# Update the results view.
|
||
|
|
if self._results: self._results.update(edge)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Help/usage
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def help(self, *e):
|
||
|
|
self._animating = 0
|
||
|
|
# The default font's not very legible; try using 'fixed' instead.
|
||
|
|
try:
|
||
|
|
ShowText(self._root, 'Help: Chart Parser Application',
|
||
|
|
(__doc__ or '').strip(), width=75, font='fixed')
|
||
|
|
except:
|
||
|
|
ShowText(self._root, 'Help: Chart Parser Application',
|
||
|
|
(__doc__ or '').strip(), width=75)
|
||
|
|
|
||
|
|
def about(self, *e):
|
||
|
|
ABOUT = ("NLTK Chart Parser Application\n"+
|
||
|
|
"Written by Edward Loper")
|
||
|
|
showinfo('About: Chart Parser Application', ABOUT)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# File Menu
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
CHART_FILE_TYPES = [('Pickle file', '.pickle'),
|
||
|
|
('All files', '*')]
|
||
|
|
GRAMMAR_FILE_TYPES = [('Plaintext grammar file', '.cfg'),
|
||
|
|
('Pickle file', '.pickle'),
|
||
|
|
('All files', '*')]
|
||
|
|
|
||
|
|
def load_chart(self, *args):
|
||
|
|
"Load a chart from a pickle file"
|
||
|
|
filename = askopenfilename(filetypes=self.CHART_FILE_TYPES,
|
||
|
|
defaultextension='.pickle')
|
||
|
|
if not filename: return
|
||
|
|
try:
|
||
|
|
with open(filename, 'rb') as infile:
|
||
|
|
chart = pickle.load(infile)
|
||
|
|
self._chart = chart
|
||
|
|
self._cv.update(chart)
|
||
|
|
if self._matrix: self._matrix.set_chart(chart)
|
||
|
|
if self._matrix: self._matrix.deselect_cell()
|
||
|
|
if self._results: self._results.set_chart(chart)
|
||
|
|
self._cp.set_chart(chart)
|
||
|
|
except Exception as e:
|
||
|
|
raise
|
||
|
|
showerror('Error Loading Chart',
|
||
|
|
'Unable to open file: %r' % filename)
|
||
|
|
|
||
|
|
def save_chart(self, *args):
|
||
|
|
"Save a chart to a pickle file"
|
||
|
|
filename = asksaveasfilename(filetypes=self.CHART_FILE_TYPES,
|
||
|
|
defaultextension='.pickle')
|
||
|
|
if not filename: return
|
||
|
|
try:
|
||
|
|
with open(filename, 'wb') as outfile:
|
||
|
|
pickle.dump(self._chart, outfile)
|
||
|
|
except Exception as e:
|
||
|
|
raise
|
||
|
|
showerror('Error Saving Chart',
|
||
|
|
'Unable to open file: %r' % filename)
|
||
|
|
|
||
|
|
def load_grammar(self, *args):
|
||
|
|
"Load a grammar from a pickle file"
|
||
|
|
filename = askopenfilename(filetypes=self.GRAMMAR_FILE_TYPES,
|
||
|
|
defaultextension='.cfg')
|
||
|
|
if not filename: return
|
||
|
|
try:
|
||
|
|
if filename.endswith('.pickle'):
|
||
|
|
with open(filename, 'rb') as infile:
|
||
|
|
grammar = pickle.load(infile)
|
||
|
|
else:
|
||
|
|
with open(filename, 'r') as infile:
|
||
|
|
grammar = CFG.fromstring(infile.read())
|
||
|
|
self.set_grammar(grammar)
|
||
|
|
except Exception as e:
|
||
|
|
showerror('Error Loading Grammar',
|
||
|
|
'Unable to open file: %r' % filename)
|
||
|
|
|
||
|
|
def save_grammar(self, *args):
|
||
|
|
filename = asksaveasfilename(filetypes=self.GRAMMAR_FILE_TYPES,
|
||
|
|
defaultextension='.cfg')
|
||
|
|
if not filename: return
|
||
|
|
try:
|
||
|
|
if filename.endswith('.pickle'):
|
||
|
|
with open(filename, 'wb') as outfile:
|
||
|
|
pickle.dump((self._chart, self._tokens), outfile)
|
||
|
|
else:
|
||
|
|
with open(filename, 'w') as outfile:
|
||
|
|
prods = self._grammar.productions()
|
||
|
|
start = [p for p in prods if p.lhs() == self._grammar.start()]
|
||
|
|
rest = [p for p in prods if p.lhs() != self._grammar.start()]
|
||
|
|
for prod in start: outfile.write('%s\n' % prod)
|
||
|
|
for prod in rest: outfile.write('%s\n' % prod)
|
||
|
|
except Exception as e:
|
||
|
|
showerror('Error Saving Grammar',
|
||
|
|
'Unable to open file: %r' % filename)
|
||
|
|
|
||
|
|
def reset(self, *args):
|
||
|
|
self._animating = 0
|
||
|
|
self._reset_parser()
|
||
|
|
self._cv.update(self._chart)
|
||
|
|
if self._matrix: self._matrix.set_chart(self._chart)
|
||
|
|
if self._matrix: self._matrix.deselect_cell()
|
||
|
|
if self._results: self._results.set_chart(self._chart)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Edit
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def edit_grammar(self, *e):
|
||
|
|
CFGEditor(self._root, self._grammar, self.set_grammar)
|
||
|
|
|
||
|
|
def set_grammar(self, grammar):
|
||
|
|
self._grammar = grammar
|
||
|
|
self._cp.set_grammar(grammar)
|
||
|
|
if self._results: self._results.set_grammar(grammar)
|
||
|
|
|
||
|
|
def edit_sentence(self, *e):
|
||
|
|
sentence = " ".join(self._tokens)
|
||
|
|
title = 'Edit Text'
|
||
|
|
instr = 'Enter a new sentence to parse.'
|
||
|
|
EntryDialog(self._root, sentence, instr, self.set_sentence, title)
|
||
|
|
|
||
|
|
def set_sentence(self, sentence):
|
||
|
|
self._tokens = list(sentence.split())
|
||
|
|
self.reset()
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# View Menu
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def view_matrix(self, *e):
|
||
|
|
if self._matrix is not None: self._matrix.destroy()
|
||
|
|
self._matrix = ChartMatrixView(self._root, self._chart)
|
||
|
|
self._matrix.add_callback('select', self._select_matrix_edge)
|
||
|
|
|
||
|
|
def view_results(self, *e):
|
||
|
|
if self._results is not None: self._results.destroy()
|
||
|
|
self._results = ChartResultsView(self._root, self._chart,
|
||
|
|
self._grammar)
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Zoom Menu
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def resize(self):
|
||
|
|
self._animating = 0
|
||
|
|
self.set_font_size(self._size.get())
|
||
|
|
|
||
|
|
def set_font_size(self, size):
|
||
|
|
self._cv.set_font_size(size)
|
||
|
|
self._font.configure(size=-abs(size))
|
||
|
|
self._boldfont.configure(size=-abs(size))
|
||
|
|
self._sysfont.configure(size=-abs(size))
|
||
|
|
|
||
|
|
def get_font_size(self):
|
||
|
|
return abs(self._size.get())
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Parsing
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
def apply_strategy(self, strategy, edge_strategy=None):
|
||
|
|
# If we're animating, then stop.
|
||
|
|
if self._animating:
|
||
|
|
self._animating = 0
|
||
|
|
return
|
||
|
|
|
||
|
|
# Clear the rule display & mark.
|
||
|
|
self._display_rule(None)
|
||
|
|
#self._cv.unmark_edge()
|
||
|
|
|
||
|
|
if self._step.get():
|
||
|
|
selection = self._selection
|
||
|
|
if (selection is not None) and (edge_strategy is not None):
|
||
|
|
# Apply the given strategy to the selected edge.
|
||
|
|
self._cp.set_strategy([edge_strategy(selection)])
|
||
|
|
newedge = self._apply_strategy()
|
||
|
|
|
||
|
|
# If it failed, then clear the selection.
|
||
|
|
if newedge is None:
|
||
|
|
self._cv.unmark_edge()
|
||
|
|
self._selection = None
|
||
|
|
else:
|
||
|
|
self._cp.set_strategy(strategy)
|
||
|
|
self._apply_strategy()
|
||
|
|
|
||
|
|
else:
|
||
|
|
self._cp.set_strategy(strategy)
|
||
|
|
if self._animate.get():
|
||
|
|
self._animating = 1
|
||
|
|
self._animate_strategy()
|
||
|
|
else:
|
||
|
|
for edge in self._cpstep:
|
||
|
|
if edge is None: break
|
||
|
|
self._cv.update()
|
||
|
|
if self._matrix: self._matrix.update()
|
||
|
|
if self._results: self._results.update()
|
||
|
|
|
||
|
|
def _stop_animation(self, *e):
|
||
|
|
self._animating = 0
|
||
|
|
|
||
|
|
def _animate_strategy(self, speed=1):
|
||
|
|
if self._animating == 0: return
|
||
|
|
if self._apply_strategy() is not None:
|
||
|
|
if self._animate.get() == 0 or self._step.get() == 1:
|
||
|
|
return
|
||
|
|
if self._animate.get() == 1:
|
||
|
|
self._root.after(3000, self._animate_strategy)
|
||
|
|
elif self._animate.get() == 2:
|
||
|
|
self._root.after(1000, self._animate_strategy)
|
||
|
|
else:
|
||
|
|
self._root.after(20, self._animate_strategy)
|
||
|
|
|
||
|
|
def _apply_strategy(self):
|
||
|
|
new_edge = next(self._cpstep)
|
||
|
|
|
||
|
|
if new_edge is not None:
|
||
|
|
self._show_new_edge(new_edge)
|
||
|
|
return new_edge
|
||
|
|
|
||
|
|
def _display_rule(self, rule):
|
||
|
|
if rule is None:
|
||
|
|
self._rulelabel2['text'] = ''
|
||
|
|
else:
|
||
|
|
name = str(rule)
|
||
|
|
self._rulelabel2['text'] = name
|
||
|
|
size = self._cv.get_font_size()
|
||
|
|
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
# Parsing Strategies
|
||
|
|
#////////////////////////////////////////////////////////////
|
||
|
|
|
||
|
|
# Basic rules:
|
||
|
|
_TD_INIT = [TopDownInitRule()]
|
||
|
|
_TD_PREDICT = [TopDownPredictRule()]
|
||
|
|
_BU_RULE = [BottomUpPredictRule()]
|
||
|
|
_BU_LC_RULE = [BottomUpPredictCombineRule()]
|
||
|
|
_FUNDAMENTAL = [SingleEdgeFundamentalRule()]
|
||
|
|
|
||
|
|
# Complete strategies:
|
||
|
|
_TD_STRATEGY = _TD_INIT + _TD_PREDICT + _FUNDAMENTAL
|
||
|
|
_BU_STRATEGY = _BU_RULE + _FUNDAMENTAL
|
||
|
|
_BU_LC_STRATEGY = _BU_LC_RULE + _FUNDAMENTAL
|
||
|
|
|
||
|
|
# Button callback functions:
|
||
|
|
def top_down_init(self, *e):
|
||
|
|
self.apply_strategy(self._TD_INIT, None)
|
||
|
|
def top_down_predict(self, *e):
|
||
|
|
self.apply_strategy(self._TD_PREDICT, TopDownPredictEdgeRule)
|
||
|
|
def bottom_up(self, *e):
|
||
|
|
self.apply_strategy(self._BU_RULE, BottomUpEdgeRule)
|
||
|
|
def bottom_up_leftcorner(self, *e):
|
||
|
|
self.apply_strategy(self._BU_LC_RULE, BottomUpLeftCornerEdgeRule)
|
||
|
|
def fundamental(self, *e):
|
||
|
|
self.apply_strategy(self._FUNDAMENTAL, FundamentalEdgeRule)
|
||
|
|
def bottom_up_strategy(self, *e):
|
||
|
|
self.apply_strategy(self._BU_STRATEGY, BottomUpEdgeRule)
|
||
|
|
def bottom_up_leftcorner_strategy(self, *e):
|
||
|
|
self.apply_strategy(self._BU_LC_STRATEGY, BottomUpLeftCornerEdgeRule)
|
||
|
|
def top_down_strategy(self, *e):
|
||
|
|
self.apply_strategy(self._TD_STRATEGY, TopDownPredictEdgeRule)
|
||
|
|
|
||
|
|
def app():
|
||
|
|
grammar = CFG.fromstring("""
|
||
|
|
# Grammatical productions.
|
||
|
|
S -> NP VP
|
||
|
|
VP -> VP PP | V NP | V
|
||
|
|
NP -> Det N | NP PP
|
||
|
|
PP -> P NP
|
||
|
|
# Lexical productions.
|
||
|
|
NP -> 'John' | 'I'
|
||
|
|
Det -> 'the' | 'my' | 'a'
|
||
|
|
N -> 'dog' | 'cookie' | 'table' | 'cake' | 'fork'
|
||
|
|
V -> 'ate' | 'saw'
|
||
|
|
P -> 'on' | 'under' | 'with'
|
||
|
|
""")
|
||
|
|
|
||
|
|
sent = 'John ate the cake on the table with a fork'
|
||
|
|
sent = 'John ate the cake on the table'
|
||
|
|
tokens = list(sent.split())
|
||
|
|
|
||
|
|
print('grammar= (')
|
||
|
|
for rule in grammar.productions():
|
||
|
|
print((' ', repr(rule)+','))
|
||
|
|
print(')')
|
||
|
|
print(('tokens = %r' % tokens))
|
||
|
|
print('Calling "ChartParserApp(grammar, tokens)"...')
|
||
|
|
ChartParserApp(grammar, tokens).mainloop()
|
||
|
|
|
||
|
|
if __name__ == '__main__':
|
||
|
|
app()
|
||
|
|
|
||
|
|
# Chart comparer:
|
||
|
|
#charts = ['/tmp/earley.pickle',
|
||
|
|
# '/tmp/topdown.pickle',
|
||
|
|
# '/tmp/bottomup.pickle']
|
||
|
|
#ChartComparer(*charts).mainloop()
|
||
|
|
|
||
|
|
#import profile
|
||
|
|
#profile.run('demo2()', '/tmp/profile.out')
|
||
|
|
#import pstats
|
||
|
|
#p = pstats.Stats('/tmp/profile.out')
|
||
|
|
#p.strip_dirs().sort_stats('time', 'cum').print_stats(60)
|
||
|
|
#p.strip_dirs().sort_stats('cum', 'time').print_stats(60)
|
||
|
|
|
||
|
|
__all__ = ['app']
|