nltk 3.2__zip → 3.3__zip

{nltk-3.2 → nltk-3.3}/nltk/app/chunkparser_app.py

@@ -1,1264 +1,1262 @@
-# Natural Language Toolkit: Regexp Chunk Parser Application
-#
-# Copyright (C) 2001-2015 NLTK Project
-# Author: Edward Loper <edloper@gmail.com>
-# URL: <http://nltk.org/>
-# For license information, see LICENSE.TXT
-
-"""
-A graphical tool for exploring the regular expression based chunk
-parser ``nltk.chunk.RegexpChunkParser``.
-"""
-
-# Todo: Add a way to select the development set from the menubar.  This
-# might just need to be a selection box (conll vs treebank etc) plus
-# configuration parameters to select what's being chunked (eg VP vs NP)
-# and what part of the data is being used as the development set.
-
-from __future__ import division
-import nltk.compat
-import time
-import textwrap
-import re
-import random
-import tkinter.filedialog, tkinter.font
-
-from tkinter import (Button, Canvas, Checkbutton,
-                     Frame, IntVar, Label, Menu,
-                     Scrollbar, Text, Tk)
-
-from nltk.tree import Tree
-from nltk.util import in_idle
-from nltk.draw.util import ShowText
-from nltk.corpus import conll2000, treebank_chunk
-from nltk.chunk import ChunkScore, RegexpChunkParser
-from nltk.chunk.regexp import RegexpChunkRule
-
-class RegexpChunkApp(object):
-    """
-    A graphical tool for exploring the regular expression based chunk
-    parser ``nltk.chunk.RegexpChunkParser``.
-
-    See ``HELP`` for instructional text.
-    """
-
-    ##/////////////////////////////////////////////////////////////////
-    ##  Help Text
-    ##/////////////////////////////////////////////////////////////////
-
-    #: A dictionary mapping from part of speech tags to descriptions,
-    #: which is used in the help text.  (This should probably live with
-    #: the conll and/or treebank corpus instead.)
-    TAGSET = {
-        'CC':   'Coordinating conjunction',   'PRP$': 'Possessive pronoun',
-        'CD':   'Cardinal number',            'RB':   'Adverb',
-        'DT':   'Determiner',                 'RBR':  'Adverb, comparative',
-        'EX':   'Existential there',          'RBS':  'Adverb, superlative',
-        'FW':   'Foreign word',               'RP':   'Particle',
-        'JJ':   'Adjective',                  'TO':   'to',
-        'JJR':  'Adjective, comparative',     'UH':   'Interjection',
-        'JJS':  'Adjective, superlative',     'VB':   'Verb, base form',
-        'LS':   'List item marker',           'VBD':  'Verb, past tense',
-        'MD':   'Modal',                      'NNS':  'Noun, plural',
-        'NN':   'Noun, singular or masps',    'VBN':  'Verb, past participle',
-        'VBZ':  'Verb,3rd ps. sing. present', 'NNP':  'Proper noun, singular',
-        'NNPS': 'Proper noun plural',         'WDT':  'wh-determiner',
-        'PDT':  'Predeterminer',              'WP':   'wh-pronoun',
-        'POS':  'Possessive ending',          'WP$':  'Possessive wh-pronoun',
-        'PRP':  'Personal pronoun',           'WRB':  'wh-adverb',
-        '(':    'open parenthesis',           ')':    'close parenthesis',
-        '``':   'open quote',                 ',':    'comma',
-        "''":   'close quote',                '.':    'period',
-        '#':    'pound sign (currency marker)',
-        '$':    'dollar sign (currency marker)',
-        'IN':   'Preposition/subord. conjunction',
-        'SYM':  'Symbol (mathematical or scientific)',
-        'VBG':  'Verb, gerund/present participle',
-        'VBP':  'Verb, non-3rd ps. sing. present',
-        ':':    'colon',
-        }
-
-    #: Contents for the help box.  This is a list of tuples, one for
-    #: each help page, where each tuple has four elements:
-    #:   - A title (displayed as a tab)
-    #:   - A string description of tabstops (see Tkinter.Text for details)
-    #:   - The text contents for the help page.  You can use expressions
-    #:     like <red>...</red> to colorize the text; see ``HELP_AUTOTAG``
-    #:     for a list of tags you can use for colorizing.
-    HELP = [
-        ('Help', '20',
-         "Welcome to the regular expression chunk-parser grammar editor.  "
-         "You can use this editor to develop and test chunk parser grammars "
-         "based on NLTK's RegexpChunkParser class.\n\n"
-         # Help box.
-         "Use this box ('Help') to learn more about the editor; click on the "
-         "tabs for help on specific topics:"
-         "<indent>\n"
-         "Rules: grammar rule types\n"
-         "Regexps: regular expression syntax\n"
-         "Tags: part of speech tags\n</indent>\n"
-         # Grammar.
-         "Use the upper-left box ('Grammar') to edit your grammar.  "
-         "Each line of your grammar specifies a single 'rule', "
-         "which performs an action such as creating a chunk or merging "
-         "two chunks.\n\n"
-         # Dev set.
-         "The lower-left box ('Development Set') runs your grammar on the "
-         "development set, and displays the results.  "
-         "Your grammar's chunks are <highlight>highlighted</highlight>, and "
-         "the correct (gold standard) chunks are "
-         "<underline>underlined</underline>.  If they "
-         "match, they are displayed in <green>green</green>; otherwise, "
-         "they are displayed in <red>red</red>.  The box displays a single "
-         "sentence from the development set at a time; use the scrollbar or "
-         "the next/previous buttons view additional sentences.\n\n"
-         # Performance
-         "The lower-right box ('Evaluation') tracks the performance of "
-         "your grammar on the development set.  The 'precision' axis "
-         "indicates how many of your grammar's chunks are correct; and "
-         "the 'recall' axis indicates how many of the gold standard "
-         "chunks your system generated.  Typically, you should try to "
-         "design a grammar that scores high on both metrics.  The "
-         "exact precision and recall of the current grammar, as well "
-         "as their harmonic mean (the 'f-score'), are displayed in "
-         "the status bar at the bottom of the window."
-         ),
-        ('Rules', '10',
-         "<h1>{...regexp...}</h1>"
-         "<indent>\nChunk rule: creates new chunks from words matching "
-         "regexp.</indent>\n\n"
-         "<h1>}...regexp...{</h1>"
-         "<indent>\nChink rule: removes words matching regexp from existing "
-         "chunks.</indent>\n\n"
-         "<h1>...regexp1...}{...regexp2...</h1>"
-         "<indent>\nSplit rule: splits chunks that match regexp1 followed by "
-         "regexp2 in two.</indent>\n\n"
-         "<h1>...regexp...{}...regexp...</h1>"
-         "<indent>\nMerge rule: joins consecutive chunks that match regexp1 "
-         "and regexp2</indent>\n"
-         ),
-        ('Regexps', '10 60',
-         #"Regular Expression Syntax Summary:\n\n"
-         "<h1>Pattern\t\tMatches...</h1>\n"
-         "<hangindent>"
-         "\t<<var>T</var>>\ta word with tag <var>T</var> "
-         "(where <var>T</var> may be a regexp).\n"
-         "\t<var>x</var>?\tan optional <var>x</var>\n"
-         "\t<var>x</var>+\ta sequence of 1 or more <var>x</var>'s\n"
-         "\t<var>x</var>*\ta sequence of 0 or more <var>x</var>'s\n"
-         "\t<var>x</var>|<var>y</var>\t<var>x</var> or <var>y</var>\n"
-         "\t.\tmatches any character\n"
-         "\t(<var>x</var>)\tTreats <var>x</var> as a group\n"
-         "\t# <var>x...</var>\tTreats <var>x...</var> "
-         "(to the end of the line) as a comment\n"
-         "\t\\<var>C</var>\tmatches character <var>C</var> "
-         "(useful when <var>C</var> is a special character "
-         "like + or #)\n"
-         "</hangindent>"
-         "\n<h1>Examples:</h1>\n"
-         "<hangindent>"
-         '\t<regexp><NN></regexp>\n'
-         '\t\tMatches <match>"cow/NN"</match>\n'
-         '\t\tMatches <match>"green/NN"</match>\n'
-         '\t<regexp><VB.*></regexp>\n'
-         '\t\tMatches <match>"eating/VBG"</match>\n'
-         '\t\tMatches <match>"ate/VBD"</match>\n'
-         '\t<regexp><IN><DT><NN></regexp>\n'
-         '\t\tMatches <match>"on/IN the/DT car/NN"</match>\n'
-         '\t<regexp><RB>?<VBD></regexp>\n'
-         '\t\tMatches <match>"ran/VBD"</match>\n'
-         '\t\tMatches <match>"slowly/RB ate/VBD"</match>\n'
-         '\t<regexp><\#><CD> # This is a comment...</regexp>\n'
-         '\t\tMatches <match>"#/# 100/CD"</match>\n'
-         "</hangindent>"
-         ),
-        ('Tags', '10 60',
-         "<h1>Part of Speech Tags:</h1>\n" +
-         '<hangindent>' +
-         '<<TAGSET>>' + # this gets auto-substituted w/ self.TAGSET
-         '</hangindent>\n')
-        ]
-
-    HELP_AUTOTAG = [
-        ('red', dict(foreground='#a00')),
-        ('green', dict(foreground='#080')),
-        ('highlight', dict(background='#ddd')),
-        ('underline', dict(underline=True)),
-        ('h1', dict(underline=True)),
-        ('indent', dict(lmargin1=20, lmargin2=20)),
-        ('hangindent', dict(lmargin1=0, lmargin2=60)),
-        ('var', dict(foreground='#88f')),
-        ('regexp', dict(foreground='#ba7')),
-        ('match', dict(foreground='#6a6')),
-        ]
-
-    ##/////////////////////////////////////////////////////////////////
-    ##  Config Parmeters
-    ##/////////////////////////////////////////////////////////////////
-
-    _EVAL_DELAY = 1
-    """If the user has not pressed any key for this amount of time (in
-       seconds), and the current grammar has not been evaluated, then
-       the eval demon will evaluate it."""
-
-    _EVAL_CHUNK = 15
-    """The number of sentences that should be evaluated by the eval
-       demon each time it runs."""
-    _EVAL_FREQ = 0.2
-    """The frequency (in seconds) at which the eval demon is run"""
-    _EVAL_DEMON_MIN = .02
-    """The minimum amount of time that the eval demon should take each time
-       it runs -- if it takes less than this time, _EVAL_CHUNK will be
-       modified upwards."""
-    _EVAL_DEMON_MAX = .04
-    """The maximum amount of time that the eval demon should take each time
-       it runs -- if it takes more than this time, _EVAL_CHUNK will be
-       modified downwards."""
-
-    _GRAMMARBOX_PARAMS = dict(
-        width=40, height=12, background='#efe', highlightbackground='#efe',
-        highlightthickness=1, relief='groove', border=2, wrap='word')
-    _HELPBOX_PARAMS = dict(
-        width=15, height=15, background='#efe', highlightbackground='#efe',
-        foreground='#555',
-        highlightthickness=1, relief='groove', border=2, wrap='word')
-    _DEVSETBOX_PARAMS = dict(
-        width=70, height=10, background='#eef', highlightbackground='#eef',
-        highlightthickness=1, relief='groove', border=2, wrap='word',
-        tabs=(30,))
-    _STATUS_PARAMS = dict(
-        background='#9bb', relief='groove', border=2)
-    _FONT_PARAMS = dict(
-        family='helvetica', size=-20)
-    _FRAME_PARAMS = dict(
-        background='#777', padx=2, pady=2, border=3)
-    _EVALBOX_PARAMS = dict(
-        background='#eef', highlightbackground='#eef',
-        highlightthickness=1, relief='groove', border=2,
-        width=300, height=280)
-    _BUTTON_PARAMS = dict(
-        background='#777', activebackground='#777',
-        highlightbackground='#777')
-    _HELPTAB_BG_COLOR = '#aba'
-    _HELPTAB_FG_COLOR = '#efe'
-
-    _HELPTAB_FG_PARAMS = dict(background='#efe')
-    _HELPTAB_BG_PARAMS = dict(background='#aba')
-    _HELPTAB_SPACER = 6
-
-    def normalize_grammar(self, grammar):
-        # Strip comments
-        grammar = re.sub(r'((\\.|[^#])*)(#.*)?', r'\1', grammar)
-        # Normalize whitespace
-        grammar = re.sub(' +', ' ', grammar)
-        grammar = re.sub('\n\s+', '\n', grammar)
-        grammar = grammar.strip()
-        # [xx] Hack: automatically backslash $!
-        grammar = re.sub(r'([^\\])\$', r'\1\\$', grammar)
-        return grammar
-
-    def __init__(self, devset_name='conll2000', devset=None,
-                 grammar = '', chunk_label='NP', tagset=None):
-        """
-        :param devset_name: The name of the development set; used for
-            display & for save files.  If either the name 'treebank'
-            or the name 'conll2000' is used, and devset is None, then
-            devset will be set automatically.
-        :param devset: A list of chunked sentences
-        :param grammar: The initial grammar to display.
-        :param tagset: Dictionary from tags to string descriptions, used
-            for the help page.  Defaults to ``self.TAGSET``.
-        """
-        self._chunk_label = chunk_label
-
-        if tagset is None: tagset = self.TAGSET
-        self.tagset = tagset
-
-        # Named development sets:
-        if devset is None:
-            if devset_name == 'conll2000':
-                devset = conll2000.chunked_sents('train.txt')#[:100]
-            elif devset == 'treebank':
-                devset = treebank_chunk.chunked_sents()#[:100]
-            else:
-                raise ValueError('Unknown development set %s' % devset_name)
-
-        self.chunker = None
-        """The chunker built from the grammar string"""
-
-        self.grammar = grammar
-        """The unparsed grammar string"""
-
-        self.normalized_grammar = None
-        """A normalized version of ``self.grammar``."""
-
-        self.grammar_changed = 0
-        """The last time() that the grammar was changed."""
-
-        self.devset = devset
-        """The development set -- a list of chunked sentences."""
-
-        self.devset_name = devset_name
-        """The name of the development set (for save files)."""
-
-        self.devset_index = -1
-        """The index into the development set of the first instance
-           that's currently being viewed."""
-
-        self._last_keypress = 0
-        """The time() when a key was most recently pressed"""
-
-        self._history = []
-        """A list of (grammar, precision, recall, fscore) tuples for
-           grammars that the user has already tried."""
-
-        self._history_index = 0
-        """When the user is scrolling through previous grammars, this
-           is used to keep track of which grammar they're looking at."""
-
-        self._eval_grammar = None
-        """The grammar that is being currently evaluated by the eval
-           demon."""
-
-        self._eval_normalized_grammar = None
-        """A normalized copy of ``_eval_grammar``."""
-
-        self._eval_index = 0
-        """The index of the next sentence in the development set that
-           should be looked at by the eval demon."""
-
-        self._eval_score = ChunkScore(chunk_label=chunk_label)
-        """The ``ChunkScore`` object that's used to keep track of the score
-        of the current grammar on the development set."""
-
-        # Set up the main window.
-        top = self.top = Tk()
-        top.geometry('+50+50')
-        top.title('Regexp Chunk Parser App')
-        top.bind('<Control-q>', self.destroy)
-
-        # Varaible that restricts how much of the devset we look at.
-        self._devset_size = IntVar(top)
-        self._devset_size.set(100)
-
-        # Set up all the tkinter widgets
-        self._init_fonts(top)
-        self._init_widgets(top)
-        self._init_bindings(top)
-        self._init_menubar(top)
-        self.grammarbox.focus()
-
-
-        # If a grammar was given, then display it.
-        if grammar:
-            self.grammarbox.insert('end', grammar+'\n')
-            self.grammarbox.mark_set('insert', '1.0')
-
-        # Display the first item in the development set
-        self.show_devset(0)
-        self.update()
-
-    def _init_bindings(self, top):
-        top.bind('<Control-n>', self._devset_next)
-        top.bind('<Control-p>', self._devset_prev)
-        top.bind('<Control-t>', self.toggle_show_trace)
-        top.bind('<KeyPress>', self.update)
-        top.bind('<Control-s>', lambda e: self.save_grammar())
-        top.bind('<Control-o>', lambda e: self.load_grammar())
-        self.grammarbox.bind('<Control-t>', self.toggle_show_trace)
-        self.grammarbox.bind('<Control-n>', self._devset_next)
-        self.grammarbox.bind('<Control-p>', self._devset_prev)
-
-        # Redraw the eval graph when the window size changes
-        self.evalbox.bind('<Configure>', self._eval_plot)
-
-    def _init_fonts(self, top):
-        # TWhat's our font size (default=same as sysfont)
-        self._size = IntVar(top)
-        self._size.set(20)
-        self._font = tkinter.font.Font(family='helvetica',
-                                 size=-self._size.get())
-        self._smallfont = tkinter.font.Font(family='helvetica',
-                                      size=-(int(self._size.get()*14//20)))
-
-    def _init_menubar(self, parent):
-        menubar = Menu(parent)
-
-        filemenu = Menu(menubar, tearoff=0)
-        filemenu.add_command(label='Reset Application', underline=0,
-                             command=self.reset)
-        filemenu.add_command(label='Save Current Grammar', underline=0,
-                             accelerator='Ctrl-s',
-                             command=self.save_grammar)
-        filemenu.add_command(label='Load Grammar', underline=0,
-                             accelerator='Ctrl-o',
-                             command=self.load_grammar)
-
-        filemenu.add_command(label='Save Grammar History', underline=13,
-                             command=self.save_history)
-
-        filemenu.add_command(label='Exit', underline=1,
-                             command=self.destroy, accelerator='Ctrl-q')
-        menubar.add_cascade(label='File', underline=0, menu=filemenu)
-
-        viewmenu = Menu(menubar, tearoff=0)
-        viewmenu.add_radiobutton(label='Tiny', variable=self._size,
-                                 underline=0, value=10, command=self.resize)
-        viewmenu.add_radiobutton(label='Small', variable=self._size,
-                                 underline=0, value=16, command=self.resize)
-        viewmenu.add_radiobutton(label='Medium', variable=self._size,
-                                 underline=0, value=20, command=self.resize)
-        viewmenu.add_radiobutton(label='Large', variable=self._size,
-                                 underline=0, value=24, command=self.resize)
-        viewmenu.add_radiobutton(label='Huge', variable=self._size,
-                                 underline=0, value=34, command=self.resize)
-        menubar.add_cascade(label='View', underline=0, menu=viewmenu)
-
-        devsetmenu = Menu(menubar, tearoff=0)
-        devsetmenu.add_radiobutton(label='50 sentences',
-                                   variable=self._devset_size,
-                                   value=50, command=self.set_devset_size)
-        devsetmenu.add_radiobutton(label='100 sentences',
-                                   variable=self._devset_size,
-                                   value=100, command=self.set_devset_size)
-        devsetmenu.add_radiobutton(label='200 sentences',
-                                   variable=self._devset_size,
-                                   value=200, command=self.set_devset_size)
-        devsetmenu.add_radiobutton(label='500 sentences',
-                                   variable=self._devset_size,
-                                   value=500, command=self.set_devset_size)
-        menubar.add_cascade(label='Development-Set', underline=0,
-                            menu=devsetmenu)
-
-        helpmenu = Menu(menubar, tearoff=0)
-        helpmenu.add_command(label='About', underline=0,
-                             command=self.about)
-        menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
-
-        parent.config(menu=menubar)
-
-    def toggle_show_trace(self, *e):
-        if self._showing_trace:
-            self.show_devset()
-        else:
-            self.show_trace()
-        return 'break'
-
-
-    _SCALE_N = 5 # center on the last 5 examples.
-    _DRAW_LINES = False
-    def _eval_plot(self, *e, **config):
-        width = config.get('width', self.evalbox.winfo_width())
-        height = config.get('height', self.evalbox.winfo_height())
-
-        # Clear the canvas
-        self.evalbox.delete('all')
-
-        # Draw the precision & recall labels.
-        tag = self.evalbox.create_text(10, height//2-10, justify='left',
-                                 anchor='w', text='Precision')
-        left, right = self.evalbox.bbox(tag)[2] + 5, width-10
-        tag = self.evalbox.create_text(left + (width-left)//2, height-10,
-                                anchor='s', text='Recall', justify='center')
-        top, bot = 10, self.evalbox.bbox(tag)[1]-10
-
-        # Draw masks for clipping the plot.
-        bg = self._EVALBOX_PARAMS['background']
-        self.evalbox.lower(self.evalbox.create_rectangle(0, 0, left-1, 5000,
-                                                         fill=bg, outline=bg))
-        self.evalbox.lower(self.evalbox.create_rectangle(0, bot+1, 5000, 5000,
-                                                         fill=bg, outline=bg))
-
-        # Calculate the plot's scale.
-        if self._autoscale.get() and len(self._history) > 1:
-            max_precision = max_recall = 0
-            min_precision = min_recall = 1
-            for i in range(1, min(len(self._history), self._SCALE_N+1)):
-                grammar, precision, recall, fmeasure = self._history[-i]
-                min_precision = min(precision, min_precision)
-                min_recall = min(recall, min_recall)
-                max_precision = max(precision, max_precision)
-                max_recall = max(recall, max_recall)
-#             if max_precision-min_precision > max_recall-min_recall:
-#                 min_recall -= (max_precision-min_precision)/2
-#                 max_recall += (max_precision-min_precision)/2
-#             else:
-#                 min_precision -= (max_recall-min_recall)/2
-#                 max_precision += (max_recall-min_recall)/2
-#             if min_recall < 0:
-#                 max_recall -= min_recall
-#                 min_recall = 0
-#             if min_precision < 0:
-#                 max_precision -= min_precision
-#                 min_precision = 0
-            min_precision = max(min_precision-.01, 0)
-            min_recall = max(min_recall-.01, 0)
-            max_precision = min(max_precision+.01, 1)
-            max_recall = min(max_recall+.01, 1)
-        else:
-            min_precision = min_recall = 0
-            max_precision = max_recall = 1
-
-        # Draw the axis lines & grid lines
-        for i in range(11):
-            x = left + (right-left)*((i/10.-min_recall)/
-                                     (max_recall-min_recall))
-            y = bot - (bot-top)*((i/10.-min_precision)/
-                                 (max_precision-min_precision))
-            if left < x < right:
-                self.evalbox.create_line(x, top, x, bot, fill='#888')
-            if top < y < bot:
-                self.evalbox.create_line(left, y, right, y, fill='#888')
-        self.evalbox.create_line(left, top, left, bot)
-        self.evalbox.create_line(left, bot, right, bot)
-
-        # Display the plot's scale
-        self.evalbox.create_text(
-            left-3, bot, justify='right', anchor='se',
-            text='%d%%' % (100*min_precision))
-        self.evalbox.create_text(
-            left-3, top, justify='right', anchor='ne',
-            text='%d%%' % (100*max_precision))
-        self.evalbox.create_text(
-            left, bot+3, justify='center', anchor='nw',
-            text='%d%%' % (100*min_recall))
-        self.evalbox.create_text(
-            right, bot+3, justify='center', anchor='ne',
-            text='%d%%' % (100*max_recall))
-
-        # Display the scores.
-        prev_x = prev_y = None
-        for i, (_, precision, recall, fscore) in enumerate(self._history):
-            x = left + (right-left) * ((recall-min_recall) /
-                                (max_recall-min_recall))
-            y = bot - (bot-top) * ((precision-min_precision) /
-                                (max_precision-min_precision))
-            if i == self._history_index:
-                self.evalbox.create_oval(x-2,y-2,x+2,y+2,
-                                         fill='#0f0', outline='#000')
-                self.status['text'] = (
-                    'Precision: %.2f%%\t' % (precision*100)+
-                    'Recall: %.2f%%\t' % (recall*100)+
-                    'F-score: %.2f%%' % (fscore*100))
-            else:
-                self.evalbox.lower(
-                    self.evalbox.create_oval(x-2,y-2,x+2,y+2,
-                                             fill='#afa', outline='#8c8'))
-            if prev_x is not None and self._eval_lines.get():
-                self.evalbox.lower(
-                    self.evalbox.create_line(prev_x, prev_y, x, y,
-                                             fill='#8c8'))
-            prev_x, prev_y = x, y
-
-    _eval_demon_running = False
-    def _eval_demon(self):
-        if self.top is None: return
-        if self.chunker is None:
-            self._eval_demon_running = False
-            return
-
-        # Note our starting time.
-        t0 = time.time()
-
-        # If are still typing, then wait for them to finish.
-        if (time.time()-self._last_keypress < self._EVAL_DELAY and
-            self.normalized_grammar != self._eval_normalized_grammar):
-            self._eval_demon_running = True
-            return self.top.after(int(self._EVAL_FREQ*1000), self._eval_demon)
-
-        # If the grammar changed, restart the evaluation.
-        if self.normalized_grammar != self._eval_normalized_grammar:
-            # Check if we've seen this grammar already.  If so, then
-            # just use the old evaluation values.
-            for (g, p, r, f) in self._history:
-                if self.normalized_grammar == self.normalize_grammar(g):
-                    self._history.append( (g, p, r, f) )
-                    self._history_index = len(self._history) - 1
-                    self._eval_plot()
-                    self._eval_demon_running = False
-                    self._eval_normalized_grammar = None
-                    return
-            self._eval_index = 0
-            self._eval_score = ChunkScore(chunk_label=self._chunk_label)
-            self._eval_grammar = self.grammar
-            self._eval_normalized_grammar = self.normalized_grammar
-
-        # If the grammar is empty, the don't bother evaluating it, or
-        # recording it in history -- the score will just be 0.
-        if self.normalized_grammar.strip() == '':
-            #self._eval_index = self._devset_size.get()
-            self._eval_demon_running = False
-            return
-
-        # Score the next set of examples
-        for gold in self.devset[self._eval_index:
-                                min(self._eval_index+self._EVAL_CHUNK,
-                                    self._devset_size.get())]:
-            guess = self._chunkparse(gold.leaves())
-            self._eval_score.score(gold, guess)
-
-        # update our index in the devset.
-        self._eval_index += self._EVAL_CHUNK
-
-        # Check if we're done
-        if self._eval_index >= self._devset_size.get():
-            self._history.append( (self._eval_grammar,
-                                   self._eval_score.precision(),
-                                   self._eval_score.recall(),
-                                   self._eval_score.f_measure()) )
-            self._history_index = len(self._history)-1
-            self._eval_plot()
-            self._eval_demon_running = False
-            self._eval_normalized_grammar = None
-        else:
-            progress = 100*self._eval_index/self._devset_size.get()
-            self.status['text'] = ('Evaluating on Development Set (%d%%)' %
-                                   progress)
-            self._eval_demon_running = True
-            self._adaptively_modify_eval_chunk(time.time() - t0)
-            self.top.after(int(self._EVAL_FREQ*1000), self._eval_demon)
-
-    def _adaptively_modify_eval_chunk(self, t):
-        """
-        Modify _EVAL_CHUNK to try to keep the amount of time that the
-        eval demon takes between _EVAL_DEMON_MIN and _EVAL_DEMON_MAX.
-
-        :param t: The amount of time that the eval demon took.
-        """
-        if t > self._EVAL_DEMON_MAX and self._EVAL_CHUNK > 5:
-            self._EVAL_CHUNK = min(self._EVAL_CHUNK-1,
-                         max(int(self._EVAL_CHUNK*(self._EVAL_DEMON_MAX/t)),
-                             self._EVAL_CHUNK-10))
-        elif t < self._EVAL_DEMON_MIN:
-            self._EVAL_CHUNK = max(self._EVAL_CHUNK+1,
-                         min(int(self._EVAL_CHUNK*(self._EVAL_DEMON_MIN/t)),
-                             self._EVAL_CHUNK+10))
-
-    def _init_widgets(self, top):
-        frame0 = Frame(top, **self._FRAME_PARAMS)
-        frame0.grid_columnconfigure(0, weight=4)
-        frame0.grid_columnconfigure(3, weight=2)
-        frame0.grid_rowconfigure(1, weight=1)
-        frame0.grid_rowconfigure(5, weight=1)
-
-        # The grammar
-        self.grammarbox = Text(frame0, font=self._font,
-                               **self._GRAMMARBOX_PARAMS)
-        self.grammarlabel = Label(frame0, font=self._font, text='Grammar:',
-                      highlightcolor='black',
-                      background=self._GRAMMARBOX_PARAMS['background'])
-        self.grammarlabel.grid(column=0, row=0, sticky='SW')
-        self.grammarbox.grid(column=0, row=1, sticky='NEWS')
-
-        # Scroll bar for grammar
-        grammar_scrollbar = Scrollbar(frame0, command=self.grammarbox.yview)
-        grammar_scrollbar.grid(column=1, row=1, sticky='NWS')
-        self.grammarbox.config(yscrollcommand=grammar_scrollbar.set)
-
-        # grammar buttons
-        bg = self._FRAME_PARAMS['background']
-        frame3 = Frame(frame0, background=bg)
-        frame3.grid(column=0, row=2, sticky='EW')
-        Button(frame3, text='Prev Grammar', command=self._history_prev,
-               **self._BUTTON_PARAMS).pack(side='left')
-        Button(frame3, text='Next Grammar', command=self._history_next,
-               **self._BUTTON_PARAMS).pack(side='left')
-
-        # Help box
-        self.helpbox = Text(frame0, font=self._smallfont,
-                            **self._HELPBOX_PARAMS)
-        self.helpbox.grid(column=3, row=1, sticky='NEWS')
-        self.helptabs = {}
-        bg = self._FRAME_PARAMS['background']
-        helptab_frame = Frame(frame0, background=bg)
-        helptab_frame.grid(column=3, row=0, sticky='SW')
-        for i, (tab, tabstops, text) in enumerate(self.HELP):
-            label = Label(helptab_frame, text=tab, font=self._smallfont)
-            label.grid(column=i*2, row=0, sticky='S')
-            #help_frame.grid_columnconfigure(i, weight=1)
-            #label.pack(side='left')
-            label.bind('<ButtonPress>', lambda e, tab=tab: self.show_help(tab))
-            self.helptabs[tab] = label
-            Frame(helptab_frame, height=1, width=self._HELPTAB_SPACER,
-                  background=bg).grid(column=i*2+1, row=0)
-        self.helptabs[self.HELP[0][0]].configure(font=self._font)
-        self.helpbox.tag_config('elide', elide=True)
-        for (tag, params) in self.HELP_AUTOTAG:
-            self.helpbox.tag_config('tag-%s' % tag, **params)
-        self.show_help(self.HELP[0][0])
-
-        # Scroll bar for helpbox
-        help_scrollbar = Scrollbar(frame0, command=self.helpbox.yview)
-        self.helpbox.config(yscrollcommand=help_scrollbar.set)
-        help_scrollbar.grid(column=4, row=1, sticky='NWS')
-
-        # The dev set
-        frame4 = Frame(frame0, background=self._FRAME_PARAMS['background'])
-        self.devsetbox = Text(frame4, font=self._font,
-                              **self._DEVSETBOX_PARAMS)
-        self.devsetbox.pack(expand=True, fill='both')
-        self.devsetlabel = Label(frame0, font=self._font,
-                      text='Development Set:', justify='right',
-                      background=self._DEVSETBOX_PARAMS['background'])
-        self.devsetlabel.grid(column=0, row=4, sticky='SW')
-        frame4.grid(column=0, row=5, sticky='NEWS')
-
-        # dev set scrollbars
-        self.devset_scroll = Scrollbar(frame0, command=self._devset_scroll)
-        self.devset_scroll.grid(column=1, row=5, sticky='NWS')
-        self.devset_xscroll = Scrollbar(frame4, command=self.devsetbox.xview,
-                                        orient='horiz')
-        self.devsetbox['xscrollcommand'] = self.devset_xscroll.set
-        self.devset_xscroll.pack(side='bottom', fill='x')
-
-        # dev set buttons
-        bg = self._FRAME_PARAMS['background']
-        frame1 = Frame(frame0, background=bg)
-        frame1.grid(column=0, row=7, sticky='EW')
-        Button(frame1, text='Prev Example (Ctrl-p)',
-               command=self._devset_prev,
-               **self._BUTTON_PARAMS).pack(side='left')
-        Button(frame1, text='Next Example (Ctrl-n)',
-               command=self._devset_next,
-               **self._BUTTON_PARAMS).pack(side='left')
-        self.devset_button = Button(frame1, text='Show example',
-                                   command=self.show_devset,
-                                    state='disabled',
-                                   **self._BUTTON_PARAMS)
-        self.devset_button.pack(side='right')
-        self.trace_button = Button(frame1, text='Show trace',
-                                   command=self.show_trace,
-                                   **self._BUTTON_PARAMS)
-        self.trace_button.pack(side='right')
-
-
-        # evaluation box
-        self.evalbox = Canvas(frame0, **self._EVALBOX_PARAMS)
-        label = Label(frame0, font=self._font, text='Evaluation:',
-              justify='right', background=self._EVALBOX_PARAMS['background'])
-        label.grid(column=3, row=4, sticky='SW')
-        self.evalbox.grid(column=3, row=5, sticky='NEWS', columnspan=2)
-
-        # evaluation box buttons
-        bg = self._FRAME_PARAMS['background']
-        frame2 = Frame(frame0, background=bg)
-        frame2.grid(column=3, row=7, sticky='EW')
-        self._autoscale = IntVar(self.top)
-        self._autoscale.set(False)
-        Checkbutton(frame2, variable=self._autoscale, command=self._eval_plot,
-                    text='Zoom', **self._BUTTON_PARAMS).pack(side='left')
-        self._eval_lines = IntVar(self.top)
-        self._eval_lines.set(False)
-        Checkbutton(frame2, variable=self._eval_lines, command=self._eval_plot,
-                    text='Lines', **self._BUTTON_PARAMS).pack(side='left')
-        Button(frame2, text='History',
-               **self._BUTTON_PARAMS).pack(side='right')
-
-        # The status label
-        self.status = Label(frame0, font=self._font, **self._STATUS_PARAMS)
-        self.status.grid(column=0, row=9, sticky='NEW', padx=3, pady=2,
-                         columnspan=5)
-
-        # Help box & devset box can't be edited.
-        self.helpbox['state'] = 'disabled'
-        self.devsetbox['state'] = 'disabled'
-
-        # Spacers
-        bg = self._FRAME_PARAMS['background']
-        Frame(frame0, height=10, width=0, background=bg).grid(column=0, row=3)
-        Frame(frame0, height=0, width=10, background=bg).grid(column=2, row=0)
-        Frame(frame0, height=6, width=0, background=bg).grid(column=0, row=8)
-
-        # pack the frame.
-        frame0.pack(fill='both', expand=True)
-
-        # Set up colors for the devset box
-        self.devsetbox.tag_config('true-pos', background='#afa',
-                                  underline='True')
-        self.devsetbox.tag_config('false-neg', underline='True',
-                                foreground='#800')
-        self.devsetbox.tag_config('false-pos', background='#faa')
-        self.devsetbox.tag_config('trace', foreground='#666', wrap='none')
-        self.devsetbox.tag_config('wrapindent', lmargin2=30, wrap='none')
-        self.devsetbox.tag_config('error', foreground='#800')
-
-        # And for the grammarbox
-        self.grammarbox.tag_config('error', background='#fec')
-        self.grammarbox.tag_config('comment', foreground='#840')
-        self.grammarbox.tag_config('angle', foreground='#00f')
-        self.grammarbox.tag_config('brace', foreground='#0a0')
-        self.grammarbox.tag_config('hangindent', lmargin1=0, lmargin2=40)
-
-    _showing_trace = False
-    def show_trace(self, *e):
-        self._showing_trace = True
-        self.trace_button['state'] = 'disabled'
-        self.devset_button['state'] = 'normal'
-
-        self.devsetbox['state'] = 'normal'
-        #self.devsetbox['wrap'] = 'none'
-        self.devsetbox.delete('1.0', 'end')
-        self.devsetlabel['text']='Development Set (%d/%d)' % (
-            (self.devset_index+1, self._devset_size.get()))
-
-        if self.chunker is None:
-            self.devsetbox.insert('1.0', 'Trace: waiting for a valid grammar.')
-            self.devsetbox.tag_add('error', '1.0', 'end')
-            return # can't do anything more
-
-        gold_tree = self.devset[self.devset_index]
-        rules = self.chunker.rules()
-
-        # Calculate the tag sequence
-        tagseq = '\t'
-        charnum = [1]
-        for wordnum, (word, pos) in enumerate(gold_tree.leaves()):
-            tagseq += '%s ' % pos
-            charnum.append(len(tagseq))
-        self.charnum = dict(((i, j), charnum[j])
-                            for i in range(len(rules)+1)
-                            for j in range(len(charnum)))
-        self.linenum = dict((i,i*2+2) for i in range(len(rules)+1))
-
-        for i in range(len(rules)+1):
-            if i == 0:
-                self.devsetbox.insert('end', 'Start:\n')
-                self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
-            else:
-                self.devsetbox.insert('end', 'Apply %s:\n' % rules[i-1])
-                self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
-            # Display the tag sequence.
-            self.devsetbox.insert('end', tagseq+'\n')
-            self.devsetbox.tag_add('wrapindent','end -2c linestart','end -2c')
-            # Run a partial parser, and extract gold & test chunks
-            chunker = RegexpChunkParser(rules[:i])
-            test_tree = self._chunkparse(gold_tree.leaves())
-            gold_chunks = self._chunks(gold_tree)
-            test_chunks = self._chunks(test_tree)
-            # Compare them.
-            for chunk in gold_chunks.intersection(test_chunks):
-                self._color_chunk(i, chunk, 'true-pos')
-            for chunk in gold_chunks - test_chunks:
-                self._color_chunk(i, chunk, 'false-neg')
-            for chunk in test_chunks - gold_chunks:
-                self._color_chunk(i, chunk, 'false-pos')
-        self.devsetbox.insert('end', 'Finished.\n')
-        self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
-
-        # This is a hack, because the x-scrollbar isn't updating its
-        # position right -- I'm not sure what the underlying cause is
-        # though.  (This is on OS X w/ python 2.5)
-        self.top.after(100, self.devset_xscroll.set, 0, .3)
-
-    def show_help(self, tab):
-        self.helpbox['state'] = 'normal'
-        self.helpbox.delete('1.0', 'end')
-        for (name, tabstops, text) in self.HELP:
-            if name == tab:
-                text = text.replace('<<TAGSET>>', '\n'.join(
-                    ('\t%s\t%s' % item for item in sorted(list(self.tagset.items()),
-                    key=lambda t_w:re.match('\w+',t_w[0]) and (0,t_w[0]) or (1,t_w[0])))))
-
-                self.helptabs[name].config(**self._HELPTAB_FG_PARAMS)
-                self.helpbox.config(tabs=tabstops)
-                self.helpbox.insert('1.0', text+'\n'*20)
-                C = '1.0 + %d chars'
-                for (tag, params) in self.HELP_AUTOTAG:
-                    pattern = '(?s)(<%s>)(.*?)(</%s>)' % (tag, tag)
-                    for m in re.finditer(pattern, text):
-                        self.helpbox.tag_add('elide',
-                                             C % m.start(1), C % m.end(1))
-                        self.helpbox.tag_add('tag-%s' % tag,
-                                             C % m.start(2), C % m.end(2))
-                        self.helpbox.tag_add('elide',
-                                             C % m.start(3), C % m.end(3))
-            else:
-                self.helptabs[name].config(**self._HELPTAB_BG_PARAMS)
-        self.helpbox['state'] = 'disabled'
-
-    def _history_prev(self, *e):
-        self._view_history(self._history_index-1)
-        return 'break'
-
-    def _history_next(self, *e):
-        self._view_history(self._history_index+1)
-        return 'break'
-
-    def _view_history(self, index):
-        # Bounds & sanity checking:
-        index = max(0, min(len(self._history)-1, index))
-        if not self._history: return
-        # Already viewing the requested history item?
-        if index == self._history_index:
-            return
-        # Show the requested grammar.  It will get added to _history
-        # only if they edit it (causing self.update() to get run.)
-        self.grammarbox['state'] = 'normal'
-        self.grammarbox.delete('1.0', 'end')
-        self.grammarbox.insert('end', self._history[index][0])
-        self.grammarbox.mark_set('insert', '1.0')
-        self._history_index = index
-        self._syntax_highlight_grammar(self._history[index][0])
-        # Record the normalized grammar & regenerate the chunker.
-        self.normalized_grammar = self.normalize_grammar(
-            self._history[index][0])
-        if self.normalized_grammar:
-            rules = [RegexpChunkRule.fromstring(line)
-                     for line in self.normalized_grammar.split('\n')]
-        else:
-            rules = []
-        self.chunker = RegexpChunkParser(rules)
-        # Show the score.
-        self._eval_plot()
-        # Update the devset box
-        self._highlight_devset()
-        if self._showing_trace: self.show_trace()
-        # Update the grammar label
-        if self._history_index < len(self._history)-1:
-            self.grammarlabel['text'] = 'Grammar %s/%s:' % (
-                self._history_index+1, len(self._history))
-        else:
-            self.grammarlabel['text'] = 'Grammar:'
-
-    def _devset_next(self, *e):
-        self._devset_scroll('scroll', 1, 'page')
-        return 'break'
-
-    def _devset_prev(self, *e):
-        self._devset_scroll('scroll', -1, 'page')
-        return 'break'
-
-    def destroy(self, *e):
-        if self.top is None: return
-        self.top.destroy()
-        self.top = None
-
-    def _devset_scroll(self, command, *args):
-        N = 1 # size of a page -- one sentence.
-        showing_trace = self._showing_trace
-        if command == 'scroll' and args[1].startswith('unit'):
-            self.show_devset(self.devset_index+int(args[0]))
-        elif command == 'scroll' and args[1].startswith('page'):
-            self.show_devset(self.devset_index+N*int(args[0]))
-        elif command == 'moveto':
-            self.show_devset(int(float(args[0])*self._devset_size.get()))
-        else:
-            assert 0, 'bad scroll command %s %s' % (command, args)
-        if showing_trace:
-            self.show_trace()
-
-    def show_devset(self, index=None):
-        if index is None: index = self.devset_index
-
-        # Bounds checking
-        index = min(max(0, index), self._devset_size.get()-1)
-
-        if index == self.devset_index and not self._showing_trace: return
-        self.devset_index = index
-
-        self._showing_trace = False
-        self.trace_button['state'] = 'normal'
-        self.devset_button['state'] = 'disabled'
-
-        # Clear the text box.
-        self.devsetbox['state'] = 'normal'
-        self.devsetbox['wrap'] = 'word'
-        self.devsetbox.delete('1.0', 'end')
-        self.devsetlabel['text']='Development Set (%d/%d)' % (
-            (self.devset_index+1, self._devset_size.get()))
-
-        # Add the sentences
-        sample = self.devset[self.devset_index:self.devset_index+1]
-        self.charnum = {}
-        self.linenum = {0:1}
-        for sentnum, sent in enumerate(sample):
-            linestr = ''
-            for wordnum, (word, pos) in enumerate(sent.leaves()):
-                self.charnum[sentnum, wordnum] = len(linestr)
-                linestr += '%s/%s ' % (word, pos)
-                self.charnum[sentnum, wordnum+1] = len(linestr)
-            self.devsetbox.insert('end', linestr[:-1]+'\n\n')
-
-        # Highlight chunks in the dev set
-        if self.chunker is not None:
-            self._highlight_devset()
-        self.devsetbox['state'] = 'disabled'
-
-        # Update the scrollbar
-        first = self.devset_index/self._devset_size.get()
-        last = (self.devset_index + 2) / self._devset_size.get()
-        self.devset_scroll.set(first, last)
-
-    def _chunks(self, tree):
-        chunks = set()
-        wordnum = 0
-        for child in tree:
-            if isinstance(child, Tree):
-                if child.label() == self._chunk_label:
-                    chunks.add( (wordnum, wordnum+len(child)) )
-                wordnum += len(child)
-            else:
-                wordnum += 1
-        return chunks
-
-    def _syntax_highlight_grammar(self, grammar):
-        if self.top is None: return
-        self.grammarbox.tag_remove('comment', '1.0', 'end')
-        self.grammarbox.tag_remove('angle', '1.0', 'end')
-        self.grammarbox.tag_remove('brace', '1.0', 'end')
-        self.grammarbox.tag_add('hangindent', '1.0', 'end')
-        for lineno, line in enumerate(grammar.split('\n')):
-            if not line.strip(): continue
-            m = re.match(r'(\\.|[^#])*(#.*)?', line)
-            comment_start = None
-            if m.group(2):
-                comment_start = m.start(2)
-                s = '%d.%d' % (lineno+1, m.start(2))
-                e = '%d.%d' % (lineno+1, m.end(2))
-                self.grammarbox.tag_add('comment', s, e)
-            for m in re.finditer('[<>{}]', line):
-                if comment_start is not None and m.start() >= comment_start:
-                    break
-                s = '%d.%d' % (lineno+1, m.start())
-                e = '%d.%d' % (lineno+1, m.end())
-                if m.group() in '<>':
-                    self.grammarbox.tag_add('angle', s, e)
-                else:
-                    self.grammarbox.tag_add('brace', s, e)
-
-
-    def _grammarcheck(self, grammar):
-        if self.top is None: return
-        self.grammarbox.tag_remove('error', '1.0', 'end')
-        self._grammarcheck_errs = []
-        for lineno, line in enumerate(grammar.split('\n')):
-            line = re.sub(r'((\\.|[^#])*)(#.*)?', r'\1', line)
-            line = line.strip()
-            if line:
-                try:
-                    RegexpChunkRule.fromstring(line)
-                except ValueError as e:
-                    self.grammarbox.tag_add('error', '%s.0' % (lineno+1),
-                                            '%s.0 lineend' % (lineno+1))
-        self.status['text'] = ''
-
-    def update(self, *event):
-        # Record when update was called (for grammarcheck)
-        if event:
-            self._last_keypress = time.time()
-
-        # Read the grammar from the Text box.
-        self.grammar = grammar = self.grammarbox.get('1.0', 'end')
-
-        # If the grammar hasn't changed, do nothing:
-        normalized_grammar = self.normalize_grammar(grammar)
-        if normalized_grammar == self.normalized_grammar:
-            return
-        else:
-            self.normalized_grammar = normalized_grammar
-
-        # If the grammar has changed, and we're looking at history,
-        # then stop looking at history.
-        if self._history_index < len(self._history)-1:
-            self.grammarlabel['text'] = 'Grammar:'
-
-        self._syntax_highlight_grammar(grammar)
-
-        # The grammar has changed; try parsing it.  If it doesn't
-        # parse, do nothing.  (flag error location?)
-        try:
-            # Note: the normalized grammar has no blank lines.
-            if normalized_grammar:
-                rules = [RegexpChunkRule.fromstring(line)
-                         for line in normalized_grammar.split('\n')]
-            else:
-                rules = []
-        except ValueError as e:
-            # Use the un-normalized grammar for error highlighting.
-            self._grammarcheck(grammar)
-            self.chunker = None
-            return
-
-        self.chunker = RegexpChunkParser(rules)
-        self.grammarbox.tag_remove('error', '1.0', 'end')
-        self.grammar_changed = time.time()
-        # Display the results
-        if self._showing_trace:
-            self.show_trace()
-        else:
-            self._highlight_devset()
-        # Start the eval demon
-        if not self._eval_demon_running:
-            self._eval_demon()
-
-    def _highlight_devset(self, sample=None):
-        if sample is None:
-            sample = self.devset[self.devset_index:self.devset_index+1]
-
-        self.devsetbox.tag_remove('true-pos', '1.0', 'end')
-        self.devsetbox.tag_remove('false-neg', '1.0', 'end')
-        self.devsetbox.tag_remove('false-pos', '1.0', 'end')
-
-        # Run the grammar on the test cases.
-        for sentnum, gold_tree in enumerate(sample):
-            # Run the chunk parser
-            test_tree = self._chunkparse(gold_tree.leaves())
-            # Extract gold & test chunks
-            gold_chunks = self._chunks(gold_tree)
-            test_chunks = self._chunks(test_tree)
-            # Compare them.
-            for chunk in gold_chunks.intersection(test_chunks):
-                self._color_chunk(sentnum, chunk, 'true-pos')
-            for chunk in gold_chunks - test_chunks:
-                self._color_chunk(sentnum, chunk, 'false-neg')
-            for chunk in test_chunks - gold_chunks:
-                self._color_chunk(sentnum, chunk, 'false-pos')
-
-    def _chunkparse(self, words):
-        try:
-            return self.chunker.parse(words)
-        except (ValueError, IndexError) as e:
-            # There's an error somewhere in the grammar, but we're not sure
-            # exactly where, so just mark the whole grammar as bad.
-            # E.g., this is caused by: "({<NN>})"
-            self.grammarbox.tag_add('error', '1.0', 'end')
-            # Treat it as tagging nothing:
-            return words
-
-    def _color_chunk(self, sentnum, chunk, tag):
-        start, end = chunk
-        self.devsetbox.tag_add(tag,
-            '%s.%s' % (self.linenum[sentnum], self.charnum[sentnum, start]),
-            '%s.%s' % (self.linenum[sentnum], self.charnum[sentnum, end]-1))
-
-    def reset(self):
-        # Clear various variables
-        self.chunker = None
-        self.grammar = None
-        self.normalized_grammar = None
-        self.grammar_changed = 0
-        self._history = []
-        self._history_index = 0
-        # Update the on-screen display.
-        self.grammarbox.delete('1.0', 'end')
-        self.show_devset(0)
-        self.update()
-        #self._eval_plot()
-
-    SAVE_GRAMMAR_TEMPLATE = (
-        '# Regexp Chunk Parsing Grammar\n'
-        '# Saved %(date)s\n'
-        '#\n'
-        '# Development set: %(devset)s\n'
-        '#   Precision: %(precision)s\n'
-        '#   Recall:    %(recall)s\n'
-        '#   F-score:   %(fscore)s\n\n'
-        '%(grammar)s\n')
-
-    def save_grammar(self, filename=None):
-        if not filename:
-            ftypes = [('Chunk Gramamr', '.chunk'),
-                      ('All files', '*')]
-            filename = tkinter.filedialog.asksaveasfilename(filetypes=ftypes,
-                                                      defaultextension='.chunk')
-            if not filename: return
-        if (self._history and self.normalized_grammar ==
-            self.normalize_grammar(self._history[-1][0])):
-            precision, recall, fscore = ['%.2f%%' % (100*v) for v in
-                                         self._history[-1][1:]]
-        elif self.chunker is None:
-            precision = recall = fscore = 'Grammar not well formed'
-        else:
-            precision = recall = fscore = 'Not finished evaluation yet'
-
-        with open(filename, 'w') as outfile:
-            outfile.write(self.SAVE_GRAMMAR_TEMPLATE % dict(
-                date=time.ctime(), devset=self.devset_name,
-                precision=precision, recall=recall, fscore=fscore,
-                grammar=self.grammar.strip()))
-
-    def load_grammar(self, filename=None):
-        if not filename:
-            ftypes = [('Chunk Gramamr', '.chunk'),
-                      ('All files', '*')]
-            filename = tkinter.filedialog.askopenfilename(filetypes=ftypes,
-                                                    defaultextension='.chunk')
-            if not filename: return
-        self.grammarbox.delete('1.0', 'end')
-        self.update()
-        with open(filename, 'r') as infile:
-            grammar = infile.read()
-        grammar = re.sub('^\# Regexp Chunk Parsing Grammar[\s\S]*'
-                         'F-score:.*\n', '', grammar).lstrip()
-        self.grammarbox.insert('1.0', grammar)
-        self.update()
-
-    def save_history(self, filename=None):
-        if not filename:
-            ftypes = [('Chunk Gramamr History', '.txt'),
-                      ('All files', '*')]
-            filename = tkinter.filedialog.asksaveasfilename(filetypes=ftypes,
-                                                      defaultextension='.txt')
-            if not filename: return
-
-        with open(filename, 'w') as outfile:
-            outfile.write('# Regexp Chunk Parsing Grammar History\n')
-            outfile.write('# Saved %s\n' % time.ctime())
-            outfile.write('# Development set: %s\n' % self.devset_name)
-            for i, (g, p, r, f) in enumerate(self._history):
-                hdr = ('Grammar %d/%d (precision=%.2f%%, recall=%.2f%%, '
-                       'fscore=%.2f%%)' % (i+1, len(self._history),
-                                           p*100, r*100, f*100))
-                outfile.write('\n%s\n' % hdr)
-                outfile.write(''.join('  %s\n' % line for line in g.strip().split()))
-
-            if not (self._history and self.normalized_grammar ==
-                    self.normalize_grammar(self._history[-1][0])):
-                if self.chunker is None:
-                    outfile.write('\nCurrent Grammar (not well-formed)\n')
-                else:
-                    outfile.write('\nCurrent Grammar (not evaluated)\n')
-                outfile.write(''.join('  %s\n' % line for line
-                                  in self.grammar.strip().split()))
-
-    def about(self, *e):
-        ABOUT = ("NLTK RegExp Chunk Parser Application\n"+
-                 "Written by Edward Loper")
-        TITLE = 'About: Regular Expression Chunk Parser Application'
-        try:
-            from tkinter.messagebox import Message
-            Message(message=ABOUT, title=TITLE).show()
-        except:
-            ShowText(self.top, TITLE, ABOUT)
-
-    def set_devset_size(self, size=None):
-        if size is not None: self._devset_size.set(size)
-        self._devset_size.set(min(len(self.devset), self._devset_size.get()))
-        self.show_devset(1)
-        self.show_devset(0)
-        # what about history?  Evaluated at diff dev set sizes!
-
-    def resize(self, size=None):
-        if size is not None: self._size.set(size)
-        size = self._size.get()
-        self._font.configure(size=-(abs(size)))
-        self._smallfont.configure(size=min(-10, -(abs(size))*14//20))
-
-    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.top.mainloop(*args, **kwargs)
-
-def app():
-    RegexpChunkApp().mainloop()
-
-if __name__ == '__main__':
-    app()
-
-__all__ = ['app']
-
+# Natural Language Toolkit: Regexp Chunk Parser Application
+#
+# Copyright (C) 2001-2018 NLTK Project
+# Author: Edward Loper <edloper@gmail.com>
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A graphical tool for exploring the regular expression based chunk
+parser ``nltk.chunk.RegexpChunkParser``.
+"""
+
+# Todo: Add a way to select the development set from the menubar.  This
+# might just need to be a selection box (conll vs treebank etc) plus
+# configuration parameters to select what's being chunked (eg VP vs NP)
+# and what part of the data is being used as the development set.
+
+from __future__ import division
+import time
+import textwrap
+import re
+import random
+
+from six.moves.tkinter import (Button, Canvas, Checkbutton, Frame, IntVar,
+                               Label, Menu, Scrollbar, Text, Tk)
+from six.moves.tkinter_tkfiledialog import askopenfilename, asksaveasfilename
+from six.moves.tkinter_font import Font
+
+from nltk.tree import Tree
+from nltk.util import in_idle
+from nltk.draw.util import ShowText
+from nltk.corpus import conll2000, treebank_chunk
+from nltk.chunk import ChunkScore, RegexpChunkParser
+from nltk.chunk.regexp import RegexpChunkRule
+
+class RegexpChunkApp(object):
+    """
+    A graphical tool for exploring the regular expression based chunk
+    parser ``nltk.chunk.RegexpChunkParser``.
+
+    See ``HELP`` for instructional text.
+    """
+
+    ##/////////////////////////////////////////////////////////////////
+    ##  Help Text
+    ##/////////////////////////////////////////////////////////////////
+
+    #: A dictionary mapping from part of speech tags to descriptions,
+    #: which is used in the help text.  (This should probably live with
+    #: the conll and/or treebank corpus instead.)
+    TAGSET = {
+        'CC':   'Coordinating conjunction',   'PRP$': 'Possessive pronoun',
+        'CD':   'Cardinal number',            'RB':   'Adverb',
+        'DT':   'Determiner',                 'RBR':  'Adverb, comparative',
+        'EX':   'Existential there',          'RBS':  'Adverb, superlative',
+        'FW':   'Foreign word',               'RP':   'Particle',
+        'JJ':   'Adjective',                  'TO':   'to',
+        'JJR':  'Adjective, comparative',     'UH':   'Interjection',
+        'JJS':  'Adjective, superlative',     'VB':   'Verb, base form',
+        'LS':   'List item marker',           'VBD':  'Verb, past tense',
+        'MD':   'Modal',                      'NNS':  'Noun, plural',
+        'NN':   'Noun, singular or masps',    'VBN':  'Verb, past participle',
+        'VBZ':  'Verb,3rd ps. sing. present', 'NNP':  'Proper noun, singular',
+        'NNPS': 'Proper noun plural',         'WDT':  'wh-determiner',
+        'PDT':  'Predeterminer',              'WP':   'wh-pronoun',
+        'POS':  'Possessive ending',          'WP$':  'Possessive wh-pronoun',
+        'PRP':  'Personal pronoun',           'WRB':  'wh-adverb',
+        '(':    'open parenthesis',           ')':    'close parenthesis',
+        '``':   'open quote',                 ',':    'comma',
+        "''":   'close quote',                '.':    'period',
+        '#':    'pound sign (currency marker)',
+        '$':    'dollar sign (currency marker)',
+        'IN':   'Preposition/subord. conjunction',
+        'SYM':  'Symbol (mathematical or scientific)',
+        'VBG':  'Verb, gerund/present participle',
+        'VBP':  'Verb, non-3rd ps. sing. present',
+        ':':    'colon',
+        }
+
+    #: Contents for the help box.  This is a list of tuples, one for
+    #: each help page, where each tuple has four elements:
+    #:   - A title (displayed as a tab)
+    #:   - A string description of tabstops (see Tkinter.Text for details)
+    #:   - The text contents for the help page.  You can use expressions
+    #:     like <red>...</red> to colorize the text; see ``HELP_AUTOTAG``
+    #:     for a list of tags you can use for colorizing.
+    HELP = [
+        ('Help', '20',
+         "Welcome to the regular expression chunk-parser grammar editor.  "
+         "You can use this editor to develop and test chunk parser grammars "
+         "based on NLTK's RegexpChunkParser class.\n\n"
+         # Help box.
+         "Use this box ('Help') to learn more about the editor; click on the "
+         "tabs for help on specific topics:"
+         "<indent>\n"
+         "Rules: grammar rule types\n"
+         "Regexps: regular expression syntax\n"
+         "Tags: part of speech tags\n</indent>\n"
+         # Grammar.
+         "Use the upper-left box ('Grammar') to edit your grammar.  "
+         "Each line of your grammar specifies a single 'rule', "
+         "which performs an action such as creating a chunk or merging "
+         "two chunks.\n\n"
+         # Dev set.
+         "The lower-left box ('Development Set') runs your grammar on the "
+         "development set, and displays the results.  "
+         "Your grammar's chunks are <highlight>highlighted</highlight>, and "
+         "the correct (gold standard) chunks are "
+         "<underline>underlined</underline>.  If they "
+         "match, they are displayed in <green>green</green>; otherwise, "
+         "they are displayed in <red>red</red>.  The box displays a single "
+         "sentence from the development set at a time; use the scrollbar or "
+         "the next/previous buttons view additional sentences.\n\n"
+         # Performance
+         "The lower-right box ('Evaluation') tracks the performance of "
+         "your grammar on the development set.  The 'precision' axis "
+         "indicates how many of your grammar's chunks are correct; and "
+         "the 'recall' axis indicates how many of the gold standard "
+         "chunks your system generated.  Typically, you should try to "
+         "design a grammar that scores high on both metrics.  The "
+         "exact precision and recall of the current grammar, as well "
+         "as their harmonic mean (the 'f-score'), are displayed in "
+         "the status bar at the bottom of the window."
+         ),
+        ('Rules', '10',
+         "<h1>{...regexp...}</h1>"
+         "<indent>\nChunk rule: creates new chunks from words matching "
+         "regexp.</indent>\n\n"
+         "<h1>}...regexp...{</h1>"
+         "<indent>\nChink rule: removes words matching regexp from existing "
+         "chunks.</indent>\n\n"
+         "<h1>...regexp1...}{...regexp2...</h1>"
+         "<indent>\nSplit rule: splits chunks that match regexp1 followed by "
+         "regexp2 in two.</indent>\n\n"
+         "<h1>...regexp...{}...regexp...</h1>"
+         "<indent>\nMerge rule: joins consecutive chunks that match regexp1 "
+         "and regexp2</indent>\n"
+         ),
+        ('Regexps', '10 60',
+         #"Regular Expression Syntax Summary:\n\n"
+         "<h1>Pattern\t\tMatches...</h1>\n"
+         "<hangindent>"
+         "\t<<var>T</var>>\ta word with tag <var>T</var> "
+         "(where <var>T</var> may be a regexp).\n"
+         "\t<var>x</var>?\tan optional <var>x</var>\n"
+         "\t<var>x</var>+\ta sequence of 1 or more <var>x</var>'s\n"
+         "\t<var>x</var>*\ta sequence of 0 or more <var>x</var>'s\n"
+         "\t<var>x</var>|<var>y</var>\t<var>x</var> or <var>y</var>\n"
+         "\t.\tmatches any character\n"
+         "\t(<var>x</var>)\tTreats <var>x</var> as a group\n"
+         "\t# <var>x...</var>\tTreats <var>x...</var> "
+         "(to the end of the line) as a comment\n"
+         "\t\\<var>C</var>\tmatches character <var>C</var> "
+         "(useful when <var>C</var> is a special character "
+         "like + or #)\n"
+         "</hangindent>"
+         "\n<h1>Examples:</h1>\n"
+         "<hangindent>"
+         '\t<regexp><NN></regexp>\n'
+         '\t\tMatches <match>"cow/NN"</match>\n'
+         '\t\tMatches <match>"green/NN"</match>\n'
+         '\t<regexp><VB.*></regexp>\n'
+         '\t\tMatches <match>"eating/VBG"</match>\n'
+         '\t\tMatches <match>"ate/VBD"</match>\n'
+         '\t<regexp><IN><DT><NN></regexp>\n'
+         '\t\tMatches <match>"on/IN the/DT car/NN"</match>\n'
+         '\t<regexp><RB>?<VBD></regexp>\n'
+         '\t\tMatches <match>"ran/VBD"</match>\n'
+         '\t\tMatches <match>"slowly/RB ate/VBD"</match>\n'
+         '\t<regexp><\#><CD> # This is a comment...</regexp>\n'
+         '\t\tMatches <match>"#/# 100/CD"</match>\n'
+         "</hangindent>"
+         ),
+        ('Tags', '10 60',
+         "<h1>Part of Speech Tags:</h1>\n" +
+         '<hangindent>' +
+         '<<TAGSET>>' + # this gets auto-substituted w/ self.TAGSET
+         '</hangindent>\n')
+        ]
+
+    HELP_AUTOTAG = [
+        ('red', dict(foreground='#a00')),
+        ('green', dict(foreground='#080')),
+        ('highlight', dict(background='#ddd')),
+        ('underline', dict(underline=True)),
+        ('h1', dict(underline=True)),
+        ('indent', dict(lmargin1=20, lmargin2=20)),
+        ('hangindent', dict(lmargin1=0, lmargin2=60)),
+        ('var', dict(foreground='#88f')),
+        ('regexp', dict(foreground='#ba7')),
+        ('match', dict(foreground='#6a6')),
+        ]
+
+    ##/////////////////////////////////////////////////////////////////
+    ##  Config Parmeters
+    ##/////////////////////////////////////////////////////////////////
+
+    _EVAL_DELAY = 1
+    """If the user has not pressed any key for this amount of time (in
+       seconds), and the current grammar has not been evaluated, then
+       the eval demon will evaluate it."""
+
+    _EVAL_CHUNK = 15
+    """The number of sentences that should be evaluated by the eval
+       demon each time it runs."""
+    _EVAL_FREQ = 0.2
+    """The frequency (in seconds) at which the eval demon is run"""
+    _EVAL_DEMON_MIN = .02
+    """The minimum amount of time that the eval demon should take each time
+       it runs -- if it takes less than this time, _EVAL_CHUNK will be
+       modified upwards."""
+    _EVAL_DEMON_MAX = .04
+    """The maximum amount of time that the eval demon should take each time
+       it runs -- if it takes more than this time, _EVAL_CHUNK will be
+       modified downwards."""
+
+    _GRAMMARBOX_PARAMS = dict(
+        width=40, height=12, background='#efe', highlightbackground='#efe',
+        highlightthickness=1, relief='groove', border=2, wrap='word')
+    _HELPBOX_PARAMS = dict(
+        width=15, height=15, background='#efe', highlightbackground='#efe',
+        foreground='#555',
+        highlightthickness=1, relief='groove', border=2, wrap='word')
+    _DEVSETBOX_PARAMS = dict(
+        width=70, height=10, background='#eef', highlightbackground='#eef',
+        highlightthickness=1, relief='groove', border=2, wrap='word',
+        tabs=(30,))
+    _STATUS_PARAMS = dict(
+        background='#9bb', relief='groove', border=2)
+    _FONT_PARAMS = dict(
+        family='helvetica', size=-20)
+    _FRAME_PARAMS = dict(
+        background='#777', padx=2, pady=2, border=3)
+    _EVALBOX_PARAMS = dict(
+        background='#eef', highlightbackground='#eef',
+        highlightthickness=1, relief='groove', border=2,
+        width=300, height=280)
+    _BUTTON_PARAMS = dict(
+        background='#777', activebackground='#777',
+        highlightbackground='#777')
+    _HELPTAB_BG_COLOR = '#aba'
+    _HELPTAB_FG_COLOR = '#efe'
+
+    _HELPTAB_FG_PARAMS = dict(background='#efe')
+    _HELPTAB_BG_PARAMS = dict(background='#aba')
+    _HELPTAB_SPACER = 6
+
+    def normalize_grammar(self, grammar):
+        # Strip comments
+        grammar = re.sub(r'((\\.|[^#])*)(#.*)?', r'\1', grammar)
+        # Normalize whitespace
+        grammar = re.sub(' +', ' ', grammar)
+        grammar = re.sub('\n\s+', '\n', grammar)
+        grammar = grammar.strip()
+        # [xx] Hack: automatically backslash $!
+        grammar = re.sub(r'([^\\])\$', r'\1\\$', grammar)
+        return grammar
+
+    def __init__(self, devset_name='conll2000', devset=None,
+                 grammar = '', chunk_label='NP', tagset=None):
+        """
+        :param devset_name: The name of the development set; used for
+            display & for save files.  If either the name 'treebank'
+            or the name 'conll2000' is used, and devset is None, then
+            devset will be set automatically.
+        :param devset: A list of chunked sentences
+        :param grammar: The initial grammar to display.
+        :param tagset: Dictionary from tags to string descriptions, used
+            for the help page.  Defaults to ``self.TAGSET``.
+        """
+        self._chunk_label = chunk_label
+
+        if tagset is None: tagset = self.TAGSET
+        self.tagset = tagset
+
+        # Named development sets:
+        if devset is None:
+            if devset_name == 'conll2000':
+                devset = conll2000.chunked_sents('train.txt')#[:100]
+            elif devset == 'treebank':
+                devset = treebank_chunk.chunked_sents()#[:100]
+            else:
+                raise ValueError('Unknown development set %s' % devset_name)
+
+        self.chunker = None
+        """The chunker built from the grammar string"""
+
+        self.grammar = grammar
+        """The unparsed grammar string"""
+
+        self.normalized_grammar = None
+        """A normalized version of ``self.grammar``."""
+
+        self.grammar_changed = 0
+        """The last time() that the grammar was changed."""
+
+        self.devset = devset
+        """The development set -- a list of chunked sentences."""
+
+        self.devset_name = devset_name
+        """The name of the development set (for save files)."""
+
+        self.devset_index = -1
+        """The index into the development set of the first instance
+           that's currently being viewed."""
+
+        self._last_keypress = 0
+        """The time() when a key was most recently pressed"""
+
+        self._history = []
+        """A list of (grammar, precision, recall, fscore) tuples for
+           grammars that the user has already tried."""
+
+        self._history_index = 0
+        """When the user is scrolling through previous grammars, this
+           is used to keep track of which grammar they're looking at."""
+
+        self._eval_grammar = None
+        """The grammar that is being currently evaluated by the eval
+           demon."""
+
+        self._eval_normalized_grammar = None
+        """A normalized copy of ``_eval_grammar``."""
+
+        self._eval_index = 0
+        """The index of the next sentence in the development set that
+           should be looked at by the eval demon."""
+
+        self._eval_score = ChunkScore(chunk_label=chunk_label)
+        """The ``ChunkScore`` object that's used to keep track of the score
+        of the current grammar on the development set."""
+
+        # Set up the main window.
+        top = self.top = Tk()
+        top.geometry('+50+50')
+        top.title('Regexp Chunk Parser App')
+        top.bind('<Control-q>', self.destroy)
+
+        # Varaible that restricts how much of the devset we look at.
+        self._devset_size = IntVar(top)
+        self._devset_size.set(100)
+
+        # Set up all the tkinter widgets
+        self._init_fonts(top)
+        self._init_widgets(top)
+        self._init_bindings(top)
+        self._init_menubar(top)
+        self.grammarbox.focus()
+
+
+        # If a grammar was given, then display it.
+        if grammar:
+            self.grammarbox.insert('end', grammar+'\n')
+            self.grammarbox.mark_set('insert', '1.0')
+
+        # Display the first item in the development set
+        self.show_devset(0)
+        self.update()
+
+    def _init_bindings(self, top):
+        top.bind('<Control-n>', self._devset_next)
+        top.bind('<Control-p>', self._devset_prev)
+        top.bind('<Control-t>', self.toggle_show_trace)
+        top.bind('<KeyPress>', self.update)
+        top.bind('<Control-s>', lambda e: self.save_grammar())
+        top.bind('<Control-o>', lambda e: self.load_grammar())
+        self.grammarbox.bind('<Control-t>', self.toggle_show_trace)
+        self.grammarbox.bind('<Control-n>', self._devset_next)
+        self.grammarbox.bind('<Control-p>', self._devset_prev)
+
+        # Redraw the eval graph when the window size changes
+        self.evalbox.bind('<Configure>', self._eval_plot)
+
+    def _init_fonts(self, top):
+        # TWhat's our font size (default=same as sysfont)
+        self._size = IntVar(top)
+        self._size.set(20)
+        self._font = Font(family='helvetica',
+                                 size=-self._size.get())
+        self._smallfont = Font(family='helvetica',
+                                      size=-(int(self._size.get()*14//20)))
+
+    def _init_menubar(self, parent):
+        menubar = Menu(parent)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(label='Reset Application', underline=0,
+                             command=self.reset)
+        filemenu.add_command(label='Save Current Grammar', underline=0,
+                             accelerator='Ctrl-s',
+                             command=self.save_grammar)
+        filemenu.add_command(label='Load Grammar', underline=0,
+                             accelerator='Ctrl-o',
+                             command=self.load_grammar)
+
+        filemenu.add_command(label='Save Grammar History', underline=13,
+                             command=self.save_history)
+
+        filemenu.add_command(label='Exit', underline=1,
+                             command=self.destroy, accelerator='Ctrl-q')
+        menubar.add_cascade(label='File', underline=0, menu=filemenu)
+
+        viewmenu = Menu(menubar, tearoff=0)
+        viewmenu.add_radiobutton(label='Tiny', variable=self._size,
+                                 underline=0, value=10, command=self.resize)
+        viewmenu.add_radiobutton(label='Small', variable=self._size,
+                                 underline=0, value=16, command=self.resize)
+        viewmenu.add_radiobutton(label='Medium', variable=self._size,
+                                 underline=0, value=20, command=self.resize)
+        viewmenu.add_radiobutton(label='Large', variable=self._size,
+                                 underline=0, value=24, command=self.resize)
+        viewmenu.add_radiobutton(label='Huge', variable=self._size,
+                                 underline=0, value=34, command=self.resize)
+        menubar.add_cascade(label='View', underline=0, menu=viewmenu)
+
+        devsetmenu = Menu(menubar, tearoff=0)
+        devsetmenu.add_radiobutton(label='50 sentences',
+                                   variable=self._devset_size,
+                                   value=50, command=self.set_devset_size)
+        devsetmenu.add_radiobutton(label='100 sentences',
+                                   variable=self._devset_size,
+                                   value=100, command=self.set_devset_size)
+        devsetmenu.add_radiobutton(label='200 sentences',
+                                   variable=self._devset_size,
+                                   value=200, command=self.set_devset_size)
+        devsetmenu.add_radiobutton(label='500 sentences',
+                                   variable=self._devset_size,
+                                   value=500, command=self.set_devset_size)
+        menubar.add_cascade(label='Development-Set', underline=0,
+                            menu=devsetmenu)
+
+        helpmenu = Menu(menubar, tearoff=0)
+        helpmenu.add_command(label='About', underline=0,
+                             command=self.about)
+        menubar.add_cascade(label='Help', underline=0, menu=helpmenu)
+
+        parent.config(menu=menubar)
+
+    def toggle_show_trace(self, *e):
+        if self._showing_trace:
+            self.show_devset()
+        else:
+            self.show_trace()
+        return 'break'
+
+
+    _SCALE_N = 5 # center on the last 5 examples.
+    _DRAW_LINES = False
+    def _eval_plot(self, *e, **config):
+        width = config.get('width', self.evalbox.winfo_width())
+        height = config.get('height', self.evalbox.winfo_height())
+
+        # Clear the canvas
+        self.evalbox.delete('all')
+
+        # Draw the precision & recall labels.
+        tag = self.evalbox.create_text(10, height//2-10, justify='left',
+                                 anchor='w', text='Precision')
+        left, right = self.evalbox.bbox(tag)[2] + 5, width-10
+        tag = self.evalbox.create_text(left + (width-left)//2, height-10,
+                                anchor='s', text='Recall', justify='center')
+        top, bot = 10, self.evalbox.bbox(tag)[1]-10
+
+        # Draw masks for clipping the plot.
+        bg = self._EVALBOX_PARAMS['background']
+        self.evalbox.lower(self.evalbox.create_rectangle(0, 0, left-1, 5000,
+                                                         fill=bg, outline=bg))
+        self.evalbox.lower(self.evalbox.create_rectangle(0, bot+1, 5000, 5000,
+                                                         fill=bg, outline=bg))
+
+        # Calculate the plot's scale.
+        if self._autoscale.get() and len(self._history) > 1:
+            max_precision = max_recall = 0
+            min_precision = min_recall = 1
+            for i in range(1, min(len(self._history), self._SCALE_N+1)):
+                grammar, precision, recall, fmeasure = self._history[-i]
+                min_precision = min(precision, min_precision)
+                min_recall = min(recall, min_recall)
+                max_precision = max(precision, max_precision)
+                max_recall = max(recall, max_recall)
+#             if max_precision-min_precision > max_recall-min_recall:
+#                 min_recall -= (max_precision-min_precision)/2
+#                 max_recall += (max_precision-min_precision)/2
+#             else:
+#                 min_precision -= (max_recall-min_recall)/2
+#                 max_precision += (max_recall-min_recall)/2
+#             if min_recall < 0:
+#                 max_recall -= min_recall
+#                 min_recall = 0
+#             if min_precision < 0:
+#                 max_precision -= min_precision
+#                 min_precision = 0
+            min_precision = max(min_precision-.01, 0)
+            min_recall = max(min_recall-.01, 0)
+            max_precision = min(max_precision+.01, 1)
+            max_recall = min(max_recall+.01, 1)
+        else:
+            min_precision = min_recall = 0
+            max_precision = max_recall = 1
+
+        # Draw the axis lines & grid lines
+        for i in range(11):
+            x = left + (right-left)*((i/10.-min_recall)/
+                                     (max_recall-min_recall))
+            y = bot - (bot-top)*((i/10.-min_precision)/
+                                 (max_precision-min_precision))
+            if left < x < right:
+                self.evalbox.create_line(x, top, x, bot, fill='#888')
+            if top < y < bot:
+                self.evalbox.create_line(left, y, right, y, fill='#888')
+        self.evalbox.create_line(left, top, left, bot)
+        self.evalbox.create_line(left, bot, right, bot)
+
+        # Display the plot's scale
+        self.evalbox.create_text(
+            left-3, bot, justify='right', anchor='se',
+            text='%d%%' % (100*min_precision))
+        self.evalbox.create_text(
+            left-3, top, justify='right', anchor='ne',
+            text='%d%%' % (100*max_precision))
+        self.evalbox.create_text(
+            left, bot+3, justify='center', anchor='nw',
+            text='%d%%' % (100*min_recall))
+        self.evalbox.create_text(
+            right, bot+3, justify='center', anchor='ne',
+            text='%d%%' % (100*max_recall))
+
+        # Display the scores.
+        prev_x = prev_y = None
+        for i, (_, precision, recall, fscore) in enumerate(self._history):
+            x = left + (right-left) * ((recall-min_recall) /
+                                (max_recall-min_recall))
+            y = bot - (bot-top) * ((precision-min_precision) /
+                                (max_precision-min_precision))
+            if i == self._history_index:
+                self.evalbox.create_oval(x-2,y-2,x+2,y+2,
+                                         fill='#0f0', outline='#000')
+                self.status['text'] = (
+                    'Precision: %.2f%%\t' % (precision*100)+
+                    'Recall: %.2f%%\t' % (recall*100)+
+                    'F-score: %.2f%%' % (fscore*100))
+            else:
+                self.evalbox.lower(
+                    self.evalbox.create_oval(x-2,y-2,x+2,y+2,
+                                             fill='#afa', outline='#8c8'))
+            if prev_x is not None and self._eval_lines.get():
+                self.evalbox.lower(
+                    self.evalbox.create_line(prev_x, prev_y, x, y,
+                                             fill='#8c8'))
+            prev_x, prev_y = x, y
+
+    _eval_demon_running = False
+    def _eval_demon(self):
+        if self.top is None: return
+        if self.chunker is None:
+            self._eval_demon_running = False
+            return
+
+        # Note our starting time.
+        t0 = time.time()
+
+        # If are still typing, then wait for them to finish.
+        if (time.time()-self._last_keypress < self._EVAL_DELAY and
+            self.normalized_grammar != self._eval_normalized_grammar):
+            self._eval_demon_running = True
+            return self.top.after(int(self._EVAL_FREQ*1000), self._eval_demon)
+
+        # If the grammar changed, restart the evaluation.
+        if self.normalized_grammar != self._eval_normalized_grammar:
+            # Check if we've seen this grammar already.  If so, then
+            # just use the old evaluation values.
+            for (g, p, r, f) in self._history:
+                if self.normalized_grammar == self.normalize_grammar(g):
+                    self._history.append( (g, p, r, f) )
+                    self._history_index = len(self._history) - 1
+                    self._eval_plot()
+                    self._eval_demon_running = False
+                    self._eval_normalized_grammar = None
+                    return
+            self._eval_index = 0
+            self._eval_score = ChunkScore(chunk_label=self._chunk_label)
+            self._eval_grammar = self.grammar
+            self._eval_normalized_grammar = self.normalized_grammar
+
+        # If the grammar is empty, the don't bother evaluating it, or
+        # recording it in history -- the score will just be 0.
+        if self.normalized_grammar.strip() == '':
+            #self._eval_index = self._devset_size.get()
+            self._eval_demon_running = False
+            return
+
+        # Score the next set of examples
+        for gold in self.devset[self._eval_index:
+                                min(self._eval_index+self._EVAL_CHUNK,
+                                    self._devset_size.get())]:
+            guess = self._chunkparse(gold.leaves())
+            self._eval_score.score(gold, guess)
+
+        # update our index in the devset.
+        self._eval_index += self._EVAL_CHUNK
+
+        # Check if we're done
+        if self._eval_index >= self._devset_size.get():
+            self._history.append( (self._eval_grammar,
+                                   self._eval_score.precision(),
+                                   self._eval_score.recall(),
+                                   self._eval_score.f_measure()) )
+            self._history_index = len(self._history)-1
+            self._eval_plot()
+            self._eval_demon_running = False
+            self._eval_normalized_grammar = None
+        else:
+            progress = 100*self._eval_index/self._devset_size.get()
+            self.status['text'] = ('Evaluating on Development Set (%d%%)' %
+                                   progress)
+            self._eval_demon_running = True
+            self._adaptively_modify_eval_chunk(time.time() - t0)
+            self.top.after(int(self._EVAL_FREQ*1000), self._eval_demon)
+
+    def _adaptively_modify_eval_chunk(self, t):
+        """
+        Modify _EVAL_CHUNK to try to keep the amount of time that the
+        eval demon takes between _EVAL_DEMON_MIN and _EVAL_DEMON_MAX.
+
+        :param t: The amount of time that the eval demon took.
+        """
+        if t > self._EVAL_DEMON_MAX and self._EVAL_CHUNK > 5:
+            self._EVAL_CHUNK = min(self._EVAL_CHUNK-1,
+                         max(int(self._EVAL_CHUNK*(self._EVAL_DEMON_MAX/t)),
+                             self._EVAL_CHUNK-10))
+        elif t < self._EVAL_DEMON_MIN:
+            self._EVAL_CHUNK = max(self._EVAL_CHUNK+1,
+                         min(int(self._EVAL_CHUNK*(self._EVAL_DEMON_MIN/t)),
+                             self._EVAL_CHUNK+10))
+
+    def _init_widgets(self, top):
+        frame0 = Frame(top, **self._FRAME_PARAMS)
+        frame0.grid_columnconfigure(0, weight=4)
+        frame0.grid_columnconfigure(3, weight=2)
+        frame0.grid_rowconfigure(1, weight=1)
+        frame0.grid_rowconfigure(5, weight=1)
+
+        # The grammar
+        self.grammarbox = Text(frame0, font=self._font,
+                               **self._GRAMMARBOX_PARAMS)
+        self.grammarlabel = Label(frame0, font=self._font, text='Grammar:',
+                      highlightcolor='black',
+                      background=self._GRAMMARBOX_PARAMS['background'])
+        self.grammarlabel.grid(column=0, row=0, sticky='SW')
+        self.grammarbox.grid(column=0, row=1, sticky='NEWS')
+
+        # Scroll bar for grammar
+        grammar_scrollbar = Scrollbar(frame0, command=self.grammarbox.yview)
+        grammar_scrollbar.grid(column=1, row=1, sticky='NWS')
+        self.grammarbox.config(yscrollcommand=grammar_scrollbar.set)
+
+        # grammar buttons
+        bg = self._FRAME_PARAMS['background']
+        frame3 = Frame(frame0, background=bg)
+        frame3.grid(column=0, row=2, sticky='EW')
+        Button(frame3, text='Prev Grammar', command=self._history_prev,
+               **self._BUTTON_PARAMS).pack(side='left')
+        Button(frame3, text='Next Grammar', command=self._history_next,
+               **self._BUTTON_PARAMS).pack(side='left')
+
+        # Help box
+        self.helpbox = Text(frame0, font=self._smallfont,
+                            **self._HELPBOX_PARAMS)
+        self.helpbox.grid(column=3, row=1, sticky='NEWS')
+        self.helptabs = {}
+        bg = self._FRAME_PARAMS['background']
+        helptab_frame = Frame(frame0, background=bg)
+        helptab_frame.grid(column=3, row=0, sticky='SW')
+        for i, (tab, tabstops, text) in enumerate(self.HELP):
+            label = Label(helptab_frame, text=tab, font=self._smallfont)
+            label.grid(column=i*2, row=0, sticky='S')
+            #help_frame.grid_columnconfigure(i, weight=1)
+            #label.pack(side='left')
+            label.bind('<ButtonPress>', lambda e, tab=tab: self.show_help(tab))
+            self.helptabs[tab] = label
+            Frame(helptab_frame, height=1, width=self._HELPTAB_SPACER,
+                  background=bg).grid(column=i*2+1, row=0)
+        self.helptabs[self.HELP[0][0]].configure(font=self._font)
+        self.helpbox.tag_config('elide', elide=True)
+        for (tag, params) in self.HELP_AUTOTAG:
+            self.helpbox.tag_config('tag-%s' % tag, **params)
+        self.show_help(self.HELP[0][0])
+
+        # Scroll bar for helpbox
+        help_scrollbar = Scrollbar(frame0, command=self.helpbox.yview)
+        self.helpbox.config(yscrollcommand=help_scrollbar.set)
+        help_scrollbar.grid(column=4, row=1, sticky='NWS')
+
+        # The dev set
+        frame4 = Frame(frame0, background=self._FRAME_PARAMS['background'])
+        self.devsetbox = Text(frame4, font=self._font,
+                              **self._DEVSETBOX_PARAMS)
+        self.devsetbox.pack(expand=True, fill='both')
+        self.devsetlabel = Label(frame0, font=self._font,
+                      text='Development Set:', justify='right',
+                      background=self._DEVSETBOX_PARAMS['background'])
+        self.devsetlabel.grid(column=0, row=4, sticky='SW')
+        frame4.grid(column=0, row=5, sticky='NEWS')
+
+        # dev set scrollbars
+        self.devset_scroll = Scrollbar(frame0, command=self._devset_scroll)
+        self.devset_scroll.grid(column=1, row=5, sticky='NWS')
+        self.devset_xscroll = Scrollbar(frame4, command=self.devsetbox.xview,
+                                        orient='horiz')
+        self.devsetbox['xscrollcommand'] = self.devset_xscroll.set
+        self.devset_xscroll.pack(side='bottom', fill='x')
+
+        # dev set buttons
+        bg = self._FRAME_PARAMS['background']
+        frame1 = Frame(frame0, background=bg)
+        frame1.grid(column=0, row=7, sticky='EW')
+        Button(frame1, text='Prev Example (Ctrl-p)',
+               command=self._devset_prev,
+               **self._BUTTON_PARAMS).pack(side='left')
+        Button(frame1, text='Next Example (Ctrl-n)',
+               command=self._devset_next,
+               **self._BUTTON_PARAMS).pack(side='left')
+        self.devset_button = Button(frame1, text='Show example',
+                                   command=self.show_devset,
+                                    state='disabled',
+                                   **self._BUTTON_PARAMS)
+        self.devset_button.pack(side='right')
+        self.trace_button = Button(frame1, text='Show trace',
+                                   command=self.show_trace,
+                                   **self._BUTTON_PARAMS)
+        self.trace_button.pack(side='right')
+
+
+        # evaluation box
+        self.evalbox = Canvas(frame0, **self._EVALBOX_PARAMS)
+        label = Label(frame0, font=self._font, text='Evaluation:',
+              justify='right', background=self._EVALBOX_PARAMS['background'])
+        label.grid(column=3, row=4, sticky='SW')
+        self.evalbox.grid(column=3, row=5, sticky='NEWS', columnspan=2)
+
+        # evaluation box buttons
+        bg = self._FRAME_PARAMS['background']
+        frame2 = Frame(frame0, background=bg)
+        frame2.grid(column=3, row=7, sticky='EW')
+        self._autoscale = IntVar(self.top)
+        self._autoscale.set(False)
+        Checkbutton(frame2, variable=self._autoscale, command=self._eval_plot,
+                    text='Zoom', **self._BUTTON_PARAMS).pack(side='left')
+        self._eval_lines = IntVar(self.top)
+        self._eval_lines.set(False)
+        Checkbutton(frame2, variable=self._eval_lines, command=self._eval_plot,
+                    text='Lines', **self._BUTTON_PARAMS).pack(side='left')
+        Button(frame2, text='History',
+               **self._BUTTON_PARAMS).pack(side='right')
+
+        # The status label
+        self.status = Label(frame0, font=self._font, **self._STATUS_PARAMS)
+        self.status.grid(column=0, row=9, sticky='NEW', padx=3, pady=2,
+                         columnspan=5)
+
+        # Help box & devset box can't be edited.
+        self.helpbox['state'] = 'disabled'
+        self.devsetbox['state'] = 'disabled'
+
+        # Spacers
+        bg = self._FRAME_PARAMS['background']
+        Frame(frame0, height=10, width=0, background=bg).grid(column=0, row=3)
+        Frame(frame0, height=0, width=10, background=bg).grid(column=2, row=0)
+        Frame(frame0, height=6, width=0, background=bg).grid(column=0, row=8)
+
+        # pack the frame.
+        frame0.pack(fill='both', expand=True)
+
+        # Set up colors for the devset box
+        self.devsetbox.tag_config('true-pos', background='#afa',
+                                  underline='True')
+        self.devsetbox.tag_config('false-neg', underline='True',
+                                foreground='#800')
+        self.devsetbox.tag_config('false-pos', background='#faa')
+        self.devsetbox.tag_config('trace', foreground='#666', wrap='none')
+        self.devsetbox.tag_config('wrapindent', lmargin2=30, wrap='none')
+        self.devsetbox.tag_config('error', foreground='#800')
+
+        # And for the grammarbox
+        self.grammarbox.tag_config('error', background='#fec')
+        self.grammarbox.tag_config('comment', foreground='#840')
+        self.grammarbox.tag_config('angle', foreground='#00f')
+        self.grammarbox.tag_config('brace', foreground='#0a0')
+        self.grammarbox.tag_config('hangindent', lmargin1=0, lmargin2=40)
+
+    _showing_trace = False
+    def show_trace(self, *e):
+        self._showing_trace = True
+        self.trace_button['state'] = 'disabled'
+        self.devset_button['state'] = 'normal'
+
+        self.devsetbox['state'] = 'normal'
+        #self.devsetbox['wrap'] = 'none'
+        self.devsetbox.delete('1.0', 'end')
+        self.devsetlabel['text']='Development Set (%d/%d)' % (
+            (self.devset_index+1, self._devset_size.get()))
+
+        if self.chunker is None:
+            self.devsetbox.insert('1.0', 'Trace: waiting for a valid grammar.')
+            self.devsetbox.tag_add('error', '1.0', 'end')
+            return # can't do anything more
+
+        gold_tree = self.devset[self.devset_index]
+        rules = self.chunker.rules()
+
+        # Calculate the tag sequence
+        tagseq = '\t'
+        charnum = [1]
+        for wordnum, (word, pos) in enumerate(gold_tree.leaves()):
+            tagseq += '%s ' % pos
+            charnum.append(len(tagseq))
+        self.charnum = dict(((i, j), charnum[j])
+                            for i in range(len(rules)+1)
+                            for j in range(len(charnum)))
+        self.linenum = dict((i,i*2+2) for i in range(len(rules)+1))
+
+        for i in range(len(rules)+1):
+            if i == 0:
+                self.devsetbox.insert('end', 'Start:\n')
+                self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
+            else:
+                self.devsetbox.insert('end', 'Apply %s:\n' % rules[i-1])
+                self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
+            # Display the tag sequence.
+            self.devsetbox.insert('end', tagseq+'\n')
+            self.devsetbox.tag_add('wrapindent','end -2c linestart','end -2c')
+            # Run a partial parser, and extract gold & test chunks
+            chunker = RegexpChunkParser(rules[:i])
+            test_tree = self._chunkparse(gold_tree.leaves())
+            gold_chunks = self._chunks(gold_tree)
+            test_chunks = self._chunks(test_tree)
+            # Compare them.
+            for chunk in gold_chunks.intersection(test_chunks):
+                self._color_chunk(i, chunk, 'true-pos')
+            for chunk in gold_chunks - test_chunks:
+                self._color_chunk(i, chunk, 'false-neg')
+            for chunk in test_chunks - gold_chunks:
+                self._color_chunk(i, chunk, 'false-pos')
+        self.devsetbox.insert('end', 'Finished.\n')
+        self.devsetbox.tag_add('trace', 'end -2c linestart', 'end -2c')
+
+        # This is a hack, because the x-scrollbar isn't updating its
+        # position right -- I'm not sure what the underlying cause is
+        # though.  (This is on OS X w/ python 2.5)
+        self.top.after(100, self.devset_xscroll.set, 0, .3)
+
+    def show_help(self, tab):
+        self.helpbox['state'] = 'normal'
+        self.helpbox.delete('1.0', 'end')
+        for (name, tabstops, text) in self.HELP:
+            if name == tab:
+                text = text.replace('<<TAGSET>>', '\n'.join(
+                    ('\t%s\t%s' % item for item in sorted(list(self.tagset.items()),
+                    key=lambda t_w:re.match('\w+',t_w[0]) and (0,t_w[0]) or (1,t_w[0])))))
+
+                self.helptabs[name].config(**self._HELPTAB_FG_PARAMS)
+                self.helpbox.config(tabs=tabstops)
+                self.helpbox.insert('1.0', text+'\n'*20)
+                C = '1.0 + %d chars'
+                for (tag, params) in self.HELP_AUTOTAG:
+                    pattern = '(?s)(<%s>)(.*?)(</%s>)' % (tag, tag)
+                    for m in re.finditer(pattern, text):
+                        self.helpbox.tag_add('elide',
+                                             C % m.start(1), C % m.end(1))
+                        self.helpbox.tag_add('tag-%s' % tag,
+                                             C % m.start(2), C % m.end(2))
+                        self.helpbox.tag_add('elide',
+                                             C % m.start(3), C % m.end(3))
+            else:
+                self.helptabs[name].config(**self._HELPTAB_BG_PARAMS)
+        self.helpbox['state'] = 'disabled'
+
+    def _history_prev(self, *e):
+        self._view_history(self._history_index-1)
+        return 'break'
+
+    def _history_next(self, *e):
+        self._view_history(self._history_index+1)
+        return 'break'
+
+    def _view_history(self, index):
+        # Bounds & sanity checking:
+        index = max(0, min(len(self._history)-1, index))
+        if not self._history: return
+        # Already viewing the requested history item?
+        if index == self._history_index:
+            return
+        # Show the requested grammar.  It will get added to _history
+        # only if they edit it (causing self.update() to get run.)
+        self.grammarbox['state'] = 'normal'
+        self.grammarbox.delete('1.0', 'end')
+        self.grammarbox.insert('end', self._history[index][0])
+        self.grammarbox.mark_set('insert', '1.0')
+        self._history_index = index
+        self._syntax_highlight_grammar(self._history[index][0])
+        # Record the normalized grammar & regenerate the chunker.
+        self.normalized_grammar = self.normalize_grammar(
+            self._history[index][0])
+        if self.normalized_grammar:
+            rules = [RegexpChunkRule.fromstring(line)
+                     for line in self.normalized_grammar.split('\n')]
+        else:
+            rules = []
+        self.chunker = RegexpChunkParser(rules)
+        # Show the score.
+        self._eval_plot()
+        # Update the devset box
+        self._highlight_devset()
+        if self._showing_trace: self.show_trace()
+        # Update the grammar label
+        if self._history_index < len(self._history)-1:
+            self.grammarlabel['text'] = 'Grammar %s/%s:' % (
+                self._history_index+1, len(self._history))
+        else:
+            self.grammarlabel['text'] = 'Grammar:'
+
+    def _devset_next(self, *e):
+        self._devset_scroll('scroll', 1, 'page')
+        return 'break'
+
+    def _devset_prev(self, *e):
+        self._devset_scroll('scroll', -1, 'page')
+        return 'break'
+
+    def destroy(self, *e):
+        if self.top is None: return
+        self.top.destroy()
+        self.top = None
+
+    def _devset_scroll(self, command, *args):
+        N = 1 # size of a page -- one sentence.
+        showing_trace = self._showing_trace
+        if command == 'scroll' and args[1].startswith('unit'):
+            self.show_devset(self.devset_index+int(args[0]))
+        elif command == 'scroll' and args[1].startswith('page'):
+            self.show_devset(self.devset_index+N*int(args[0]))
+        elif command == 'moveto':
+            self.show_devset(int(float(args[0])*self._devset_size.get()))
+        else:
+            assert 0, 'bad scroll command %s %s' % (command, args)
+        if showing_trace:
+            self.show_trace()
+
+    def show_devset(self, index=None):
+        if index is None: index = self.devset_index
+
+        # Bounds checking
+        index = min(max(0, index), self._devset_size.get()-1)
+
+        if index == self.devset_index and not self._showing_trace: return
+        self.devset_index = index
+
+        self._showing_trace = False
+        self.trace_button['state'] = 'normal'
+        self.devset_button['state'] = 'disabled'
+
+        # Clear the text box.
+        self.devsetbox['state'] = 'normal'
+        self.devsetbox['wrap'] = 'word'
+        self.devsetbox.delete('1.0', 'end')
+        self.devsetlabel['text']='Development Set (%d/%d)' % (
+            (self.devset_index+1, self._devset_size.get()))
+
+        # Add the sentences
+        sample = self.devset[self.devset_index:self.devset_index+1]
+        self.charnum = {}
+        self.linenum = {0:1}
+        for sentnum, sent in enumerate(sample):
+            linestr = ''
+            for wordnum, (word, pos) in enumerate(sent.leaves()):
+                self.charnum[sentnum, wordnum] = len(linestr)
+                linestr += '%s/%s ' % (word, pos)
+                self.charnum[sentnum, wordnum+1] = len(linestr)
+            self.devsetbox.insert('end', linestr[:-1]+'\n\n')
+
+        # Highlight chunks in the dev set
+        if self.chunker is not None:
+            self._highlight_devset()
+        self.devsetbox['state'] = 'disabled'
+
+        # Update the scrollbar
+        first = self.devset_index/self._devset_size.get()
+        last = (self.devset_index + 2) / self._devset_size.get()
+        self.devset_scroll.set(first, last)
+
+    def _chunks(self, tree):
+        chunks = set()
+        wordnum = 0
+        for child in tree:
+            if isinstance(child, Tree):
+                if child.label() == self._chunk_label:
+                    chunks.add( (wordnum, wordnum+len(child)) )
+                wordnum += len(child)
+            else:
+                wordnum += 1
+        return chunks
+
+    def _syntax_highlight_grammar(self, grammar):
+        if self.top is None: return
+        self.grammarbox.tag_remove('comment', '1.0', 'end')
+        self.grammarbox.tag_remove('angle', '1.0', 'end')
+        self.grammarbox.tag_remove('brace', '1.0', 'end')
+        self.grammarbox.tag_add('hangindent', '1.0', 'end')
+        for lineno, line in enumerate(grammar.split('\n')):
+            if not line.strip(): continue
+            m = re.match(r'(\\.|[^#])*(#.*)?', line)
+            comment_start = None
+            if m.group(2):
+                comment_start = m.start(2)
+                s = '%d.%d' % (lineno+1, m.start(2))
+                e = '%d.%d' % (lineno+1, m.end(2))
+                self.grammarbox.tag_add('comment', s, e)
+            for m in re.finditer('[<>{}]', line):
+                if comment_start is not None and m.start() >= comment_start:
+                    break
+                s = '%d.%d' % (lineno+1, m.start())
+                e = '%d.%d' % (lineno+1, m.end())
+                if m.group() in '<>':
+                    self.grammarbox.tag_add('angle', s, e)
+                else:
+                    self.grammarbox.tag_add('brace', s, e)
+
+
+    def _grammarcheck(self, grammar):
+        if self.top is None: return
+        self.grammarbox.tag_remove('error', '1.0', 'end')
+        self._grammarcheck_errs = []
+        for lineno, line in enumerate(grammar.split('\n')):
+            line = re.sub(r'((\\.|[^#])*)(#.*)?', r'\1', line)
+            line = line.strip()
+            if line:
+                try:
+                    RegexpChunkRule.fromstring(line)
+                except ValueError as e:
+                    self.grammarbox.tag_add('error', '%s.0' % (lineno+1),
+                                            '%s.0 lineend' % (lineno+1))
+        self.status['text'] = ''
+
+    def update(self, *event):
+        # Record when update was called (for grammarcheck)
+        if event:
+            self._last_keypress = time.time()
+
+        # Read the grammar from the Text box.
+        self.grammar = grammar = self.grammarbox.get('1.0', 'end')
+
+        # If the grammar hasn't changed, do nothing:
+        normalized_grammar = self.normalize_grammar(grammar)
+        if normalized_grammar == self.normalized_grammar:
+            return
+        else:
+            self.normalized_grammar = normalized_grammar
+
+        # If the grammar has changed, and we're looking at history,
+        # then stop looking at history.
+        if self._history_index < len(self._history)-1:
+            self.grammarlabel['text'] = 'Grammar:'
+
+        self._syntax_highlight_grammar(grammar)
+
+        # The grammar has changed; try parsing it.  If it doesn't
+        # parse, do nothing.  (flag error location?)
+        try:
+            # Note: the normalized grammar has no blank lines.
+            if normalized_grammar:
+                rules = [RegexpChunkRule.fromstring(line)
+                         for line in normalized_grammar.split('\n')]
+            else:
+                rules = []
+        except ValueError as e:
+            # Use the un-normalized grammar for error highlighting.
+            self._grammarcheck(grammar)
+            self.chunker = None
+            return
+
+        self.chunker = RegexpChunkParser(rules)
+        self.grammarbox.tag_remove('error', '1.0', 'end')
+        self.grammar_changed = time.time()
+        # Display the results
+        if self._showing_trace:
+            self.show_trace()
+        else:
+            self._highlight_devset()
+        # Start the eval demon
+        if not self._eval_demon_running:
+            self._eval_demon()
+
+    def _highlight_devset(self, sample=None):
+        if sample is None:
+            sample = self.devset[self.devset_index:self.devset_index+1]
+
+        self.devsetbox.tag_remove('true-pos', '1.0', 'end')
+        self.devsetbox.tag_remove('false-neg', '1.0', 'end')
+        self.devsetbox.tag_remove('false-pos', '1.0', 'end')
+
+        # Run the grammar on the test cases.
+        for sentnum, gold_tree in enumerate(sample):
+            # Run the chunk parser
+            test_tree = self._chunkparse(gold_tree.leaves())
+            # Extract gold & test chunks
+            gold_chunks = self._chunks(gold_tree)
+            test_chunks = self._chunks(test_tree)
+            # Compare them.
+            for chunk in gold_chunks.intersection(test_chunks):
+                self._color_chunk(sentnum, chunk, 'true-pos')
+            for chunk in gold_chunks - test_chunks:
+                self._color_chunk(sentnum, chunk, 'false-neg')
+            for chunk in test_chunks - gold_chunks:
+                self._color_chunk(sentnum, chunk, 'false-pos')
+
+    def _chunkparse(self, words):
+        try:
+            return self.chunker.parse(words)
+        except (ValueError, IndexError) as e:
+            # There's an error somewhere in the grammar, but we're not sure
+            # exactly where, so just mark the whole grammar as bad.
+            # E.g., this is caused by: "({<NN>})"
+            self.grammarbox.tag_add('error', '1.0', 'end')
+            # Treat it as tagging nothing:
+            return words
+
+    def _color_chunk(self, sentnum, chunk, tag):
+        start, end = chunk
+        self.devsetbox.tag_add(tag,
+            '%s.%s' % (self.linenum[sentnum], self.charnum[sentnum, start]),
+            '%s.%s' % (self.linenum[sentnum], self.charnum[sentnum, end]-1))
+
+    def reset(self):
+        # Clear various variables
+        self.chunker = None
+        self.grammar = None
+        self.normalized_grammar = None
+        self.grammar_changed = 0
+        self._history = []
+        self._history_index = 0
+        # Update the on-screen display.
+        self.grammarbox.delete('1.0', 'end')
+        self.show_devset(0)
+        self.update()
+        #self._eval_plot()
+
+    SAVE_GRAMMAR_TEMPLATE = (
+        '# Regexp Chunk Parsing Grammar\n'
+        '# Saved %(date)s\n'
+        '#\n'
+        '# Development set: %(devset)s\n'
+        '#   Precision: %(precision)s\n'
+        '#   Recall:    %(recall)s\n'
+        '#   F-score:   %(fscore)s\n\n'
+        '%(grammar)s\n')
+
+    def save_grammar(self, filename=None):
+        if not filename:
+            ftypes = [('Chunk Gramamr', '.chunk'),
+                      ('All files', '*')]
+            filename = asksaveasfilename(filetypes=ftypes,
+                                                      defaultextension='.chunk')
+            if not filename: return
+        if (self._history and self.normalized_grammar ==
+            self.normalize_grammar(self._history[-1][0])):
+            precision, recall, fscore = ['%.2f%%' % (100*v) for v in
+                                         self._history[-1][1:]]
+        elif self.chunker is None:
+            precision = recall = fscore = 'Grammar not well formed'
+        else:
+            precision = recall = fscore = 'Not finished evaluation yet'
+
+        with open(filename, 'w') as outfile:
+            outfile.write(self.SAVE_GRAMMAR_TEMPLATE % dict(
+                date=time.ctime(), devset=self.devset_name,
+                precision=precision, recall=recall, fscore=fscore,
+                grammar=self.grammar.strip()))
+
+    def load_grammar(self, filename=None):
+        if not filename:
+            ftypes = [('Chunk Gramamr', '.chunk'),
+                      ('All files', '*')]
+            filename = askopenfilename(filetypes=ftypes,
+                                                    defaultextension='.chunk')
+            if not filename: return
+        self.grammarbox.delete('1.0', 'end')
+        self.update()
+        with open(filename, 'r') as infile:
+            grammar = infile.read()
+        grammar = re.sub('^\# Regexp Chunk Parsing Grammar[\s\S]*'
+                         'F-score:.*\n', '', grammar).lstrip()
+        self.grammarbox.insert('1.0', grammar)
+        self.update()
+
+    def save_history(self, filename=None):
+        if not filename:
+            ftypes = [('Chunk Gramamr History', '.txt'),
+                      ('All files', '*')]
+            filename = asksaveasfilename(filetypes=ftypes,
+                                                      defaultextension='.txt')
+            if not filename: return
+
+        with open(filename, 'w') as outfile:
+            outfile.write('# Regexp Chunk Parsing Grammar History\n')
+            outfile.write('# Saved %s\n' % time.ctime())
+            outfile.write('# Development set: %s\n' % self.devset_name)
+            for i, (g, p, r, f) in enumerate(self._history):
+                hdr = ('Grammar %d/%d (precision=%.2f%%, recall=%.2f%%, '
+                       'fscore=%.2f%%)' % (i+1, len(self._history),
+                                           p*100, r*100, f*100))
+                outfile.write('\n%s\n' % hdr)
+                outfile.write(''.join('  %s\n' % line for line in g.strip().split()))
+
+            if not (self._history and self.normalized_grammar ==
+                    self.normalize_grammar(self._history[-1][0])):
+                if self.chunker is None:
+                    outfile.write('\nCurrent Grammar (not well-formed)\n')
+                else:
+                    outfile.write('\nCurrent Grammar (not evaluated)\n')
+                outfile.write(''.join('  %s\n' % line for line
+                                  in self.grammar.strip().split()))
+
+    def about(self, *e):
+        ABOUT = ("NLTK RegExp Chunk Parser Application\n"+
+                 "Written by Edward Loper")
+        TITLE = 'About: Regular Expression Chunk Parser Application'
+        try:
+            from six.moves.tkinter_messagebox import Message
+            Message(message=ABOUT, title=TITLE).show()
+        except:
+            ShowText(self.top, TITLE, ABOUT)
+
+    def set_devset_size(self, size=None):
+        if size is not None: self._devset_size.set(size)
+        self._devset_size.set(min(len(self.devset), self._devset_size.get()))
+        self.show_devset(1)
+        self.show_devset(0)
+        # what about history?  Evaluated at diff dev set sizes!
+
+    def resize(self, size=None):
+        if size is not None: self._size.set(size)
+        size = self._size.get()
+        self._font.configure(size=-(abs(size)))
+        self._smallfont.configure(size=min(-10, -(abs(size))*14//20))
+
+    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.top.mainloop(*args, **kwargs)
+
+def app():
+    RegexpChunkApp().mainloop()
+
+if __name__ == '__main__':
+    app()
+
+__all__ = ['app']