Add files using upload-large-folder tool

.gitattributes

@@ -129,3 +129,4 @@ env-llmeval/lib/python3.10/site-packages/lxml/etree.cpython-310-x86_64-linux-gnu
 env-llmeval/lib/python3.10/site-packages/scipy.libs/libopenblasp-r0-24bff013.3.26.dev.so filter=lfs diff=lfs merge=lfs -text
 env-llmeval/lib/python3.10/site-packages/scipy.libs/libgfortran-040039e1.so.5.0.0 filter=lfs diff=lfs merge=lfs -text
 llmeval-env/lib/python3.10/site-packages/torch/lib/libtorch_cpu.so filter=lfs diff=lfs merge=lfs -text
+env-llmeval/lib/python3.10/site-packages/yaml/_yaml.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

env-llmeval/lib/python3.10/site-packages/nltk/app/__init__.py

@@ -0,0 +1,47 @@
+# Natural Language Toolkit: Applications package
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Interactive NLTK Applications:
+
+chartparser:  Chart Parser
+chunkparser:  Regular-Expression Chunk Parser
+collocations: Find collocations in text
+concordance:  Part-of-speech concordancer
+nemo:         Finding (and Replacing) Nemo regular expression tool
+rdparser:     Recursive Descent Parser
+srparser:     Shift-Reduce Parser
+wordnet:      WordNet Browser
+"""
+
+
+# Import Tkinter-based modules if Tkinter is installed
+try:
+    import tkinter
+except ImportError:
+    import warnings
+
+    warnings.warn("nltk.app package not loaded (please install Tkinter library).")
+else:
+    from nltk.app.chartparser_app import app as chartparser
+    from nltk.app.chunkparser_app import app as chunkparser
+    from nltk.app.collocations_app import app as collocations
+    from nltk.app.concordance_app import app as concordance
+    from nltk.app.nemo_app import app as nemo
+    from nltk.app.rdparser_app import app as rdparser
+    from nltk.app.srparser_app import app as srparser
+    from nltk.app.wordnet_app import app as wordnet
+
+    try:
+        from matplotlib import pylab
+    except ImportError:
+        import warnings
+
+        warnings.warn("nltk.app.wordfreq not loaded (requires the matplotlib library).")
+    else:
+        from nltk.app.wordfreq_app import app as wordfreq

env-llmeval/lib/python3.10/site-packages/nltk/app/chartparser_app.py

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

env-llmeval/lib/python3.10/site-packages/nltk/app/chunkparser_app.py

@@ -0,0 +1,1500 @@
+# Natural Language Toolkit: Regexp Chunk Parser Application
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.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.
+
+import random
+import re
+import textwrap
+import time
+from tkinter import (
+    Button,
+    Canvas,
+    Checkbutton,
+    Frame,
+    IntVar,
+    Label,
+    Menu,
+    Scrollbar,
+    Text,
+    Tk,
+)
+from tkinter.filedialog import askopenfilename, asksaveasfilename
+from tkinter.font import Font
+
+from nltk.chunk import ChunkScore, RegexpChunkParser
+from nltk.chunk.regexp import RegexpChunkRule
+from nltk.corpus import conll2000, treebank_chunk
+from nltk.draw.util import ShowText
+from nltk.tree import Tree
+from nltk.util import in_idle
+
+
+class RegexpChunkApp:
+    """
+    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>\nStrip 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'
+            r"\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>>"
+            + "</hangindent>\n",  # this gets auto-substituted w/ self.TAGSET
+        ),
+    ]
+
+    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 Parameters
+    ##/////////////////////////////////////////////////////////////////
+
+    _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 = 0.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 = 0.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(r"\n\s+", r"\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)
+
+        # Variable 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 - 0.01, 0)
+            min_recall = max(min_recall - 0.01, 0)
+            max_precision = min(max_precision + 0.01, 1)
+            max_recall = min(max_recall + 0.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.0 - min_recall) / (max_recall - min_recall)
+            )
+            y = bot - (bot - top) * (
+                (i / 10.0 - 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 = {
+            (i, j): charnum[j]
+            for i in range(len(rules) + 1)
+            for j in range(len(charnum))
+        }
+        self.linenum = {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, 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(r"\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 = f"(?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 {}/{}:".format(
+                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, f"bad scroll command {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 += f"{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,
+            f"{self.linenum[sentnum]}.{self.charnum[sentnum, start]}",
+            f"{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) as infile:
+            grammar = infile.read()
+        grammar = re.sub(
+            r"^\# 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 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"]

env-llmeval/lib/python3.10/site-packages/nltk/app/collocations_app.py

@@ -0,0 +1,438 @@
+# Natural Language Toolkit: Collocations Application
+# Much of the GUI code is imported from concordance.py; We intend to merge these tools together
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Sumukh Ghodke <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+
+import queue as q
+import threading
+from tkinter import (
+    END,
+    LEFT,
+    SUNKEN,
+    Button,
+    Frame,
+    IntVar,
+    Label,
+    Menu,
+    OptionMenu,
+    Scrollbar,
+    StringVar,
+    Text,
+    Tk,
+)
+from tkinter.font import Font
+
+from nltk.corpus import (
+    alpino,
+    brown,
+    cess_cat,
+    cess_esp,
+    floresta,
+    indian,
+    mac_morpho,
+    machado,
+    nps_chat,
+    sinica_treebank,
+    treebank,
+)
+from nltk.probability import FreqDist
+from nltk.util import in_idle
+
+CORPUS_LOADED_EVENT = "<<CL_EVENT>>"
+ERROR_LOADING_CORPUS_EVENT = "<<ELC_EVENT>>"
+POLL_INTERVAL = 100
+
+_DEFAULT = "English: Brown Corpus (Humor)"
+_CORPORA = {
+    "Catalan: CESS-CAT Corpus": lambda: cess_cat.words(),
+    "English: Brown Corpus": lambda: brown.words(),
+    "English: Brown Corpus (Press)": lambda: brown.words(
+        categories=["news", "editorial", "reviews"]
+    ),
+    "English: Brown Corpus (Religion)": lambda: brown.words(categories="religion"),
+    "English: Brown Corpus (Learned)": lambda: brown.words(categories="learned"),
+    "English: Brown Corpus (Science Fiction)": lambda: brown.words(
+        categories="science_fiction"
+    ),
+    "English: Brown Corpus (Romance)": lambda: brown.words(categories="romance"),
+    "English: Brown Corpus (Humor)": lambda: brown.words(categories="humor"),
+    "English: NPS Chat Corpus": lambda: nps_chat.words(),
+    "English: Wall Street Journal Corpus": lambda: treebank.words(),
+    "Chinese: Sinica Corpus": lambda: sinica_treebank.words(),
+    "Dutch: Alpino Corpus": lambda: alpino.words(),
+    "Hindi: Indian Languages Corpus": lambda: indian.words(files="hindi.pos"),
+    "Portuguese: Floresta Corpus (Portugal)": lambda: floresta.words(),
+    "Portuguese: MAC-MORPHO Corpus (Brazil)": lambda: mac_morpho.words(),
+    "Portuguese: Machado Corpus (Brazil)": lambda: machado.words(),
+    "Spanish: CESS-ESP Corpus": lambda: cess_esp.words(),
+}
+
+
+class CollocationsView:
+    _BACKGROUND_COLOUR = "#FFF"  # white
+
+    def __init__(self):
+        self.queue = q.Queue()
+        self.model = CollocationsModel(self.queue)
+        self.top = Tk()
+        self._init_top(self.top)
+        self._init_menubar()
+        self._init_widgets(self.top)
+        self.load_corpus(self.model.DEFAULT_CORPUS)
+        self.after = self.top.after(POLL_INTERVAL, self._poll)
+
+    def _init_top(self, top):
+        top.geometry("550x650+50+50")
+        top.title("NLTK Collocations List")
+        top.bind("<Control-q>", self.destroy)
+        top.protocol("WM_DELETE_WINDOW", self.destroy)
+        top.minsize(550, 650)
+
+    def _init_widgets(self, parent):
+        self.main_frame = Frame(
+            parent, dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1)
+        )
+        self._init_corpus_select(self.main_frame)
+        self._init_results_box(self.main_frame)
+        self._init_paging(self.main_frame)
+        self._init_status(self.main_frame)
+        self.main_frame.pack(fill="both", expand=True)
+
+    def _init_corpus_select(self, parent):
+        innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
+        self.var = StringVar(innerframe)
+        self.var.set(self.model.DEFAULT_CORPUS)
+        Label(
+            innerframe,
+            justify=LEFT,
+            text=" Corpus: ",
+            background=self._BACKGROUND_COLOUR,
+            padx=2,
+            pady=1,
+            border=0,
+        ).pack(side="left")
+
+        other_corpora = list(self.model.CORPORA.keys()).remove(
+            self.model.DEFAULT_CORPUS
+        )
+        om = OptionMenu(
+            innerframe,
+            self.var,
+            self.model.DEFAULT_CORPUS,
+            command=self.corpus_selected,
+            *self.model.non_default_corpora()
+        )
+        om["borderwidth"] = 0
+        om["highlightthickness"] = 1
+        om.pack(side="left")
+        innerframe.pack(side="top", fill="x", anchor="n")
+
+    def _init_status(self, parent):
+        self.status = Label(
+            parent,
+            justify=LEFT,
+            relief=SUNKEN,
+            background=self._BACKGROUND_COLOUR,
+            border=0,
+            padx=1,
+            pady=0,
+        )
+        self.status.pack(side="top", anchor="sw")
+
+    def _init_menubar(self):
+        self._result_size = IntVar(self.top)
+        menubar = Menu(self.top)
+
+        filemenu = Menu(menubar, tearoff=0, borderwidth=0)
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-q"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        editmenu = Menu(menubar, tearoff=0)
+        rescntmenu = Menu(editmenu, tearoff=0)
+        rescntmenu.add_radiobutton(
+            label="20",
+            variable=self._result_size,
+            underline=0,
+            value=20,
+            command=self.set_result_size,
+        )
+        rescntmenu.add_radiobutton(
+            label="50",
+            variable=self._result_size,
+            underline=0,
+            value=50,
+            command=self.set_result_size,
+        )
+        rescntmenu.add_radiobutton(
+            label="100",
+            variable=self._result_size,
+            underline=0,
+            value=100,
+            command=self.set_result_size,
+        )
+        rescntmenu.invoke(1)
+        editmenu.add_cascade(label="Result Count", underline=0, menu=rescntmenu)
+
+        menubar.add_cascade(label="Edit", underline=0, menu=editmenu)
+        self.top.config(menu=menubar)
+
+    def set_result_size(self, **kwargs):
+        self.model.result_count = self._result_size.get()
+
+    def _init_results_box(self, parent):
+        innerframe = Frame(parent)
+        i1 = Frame(innerframe)
+        i2 = Frame(innerframe)
+        vscrollbar = Scrollbar(i1, borderwidth=1)
+        hscrollbar = Scrollbar(i2, borderwidth=1, orient="horiz")
+        self.results_box = Text(
+            i1,
+            font=Font(family="courier", size="16"),
+            state="disabled",
+            borderwidth=1,
+            yscrollcommand=vscrollbar.set,
+            xscrollcommand=hscrollbar.set,
+            wrap="none",
+            width="40",
+            height="20",
+            exportselection=1,
+        )
+        self.results_box.pack(side="left", fill="both", expand=True)
+        vscrollbar.pack(side="left", fill="y", anchor="e")
+        vscrollbar.config(command=self.results_box.yview)
+        hscrollbar.pack(side="left", fill="x", expand=True, anchor="w")
+        hscrollbar.config(command=self.results_box.xview)
+        # there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
+        Label(i2, text="   ", background=self._BACKGROUND_COLOUR).pack(
+            side="left", anchor="e"
+        )
+        i1.pack(side="top", fill="both", expand=True, anchor="n")
+        i2.pack(side="bottom", fill="x", anchor="s")
+        innerframe.pack(side="top", fill="both", expand=True)
+
+    def _init_paging(self, parent):
+        innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
+        self.prev = prev = Button(
+            innerframe,
+            text="Previous",
+            command=self.previous,
+            width="10",
+            borderwidth=1,
+            highlightthickness=1,
+            state="disabled",
+        )
+        prev.pack(side="left", anchor="center")
+        self.next = next = Button(
+            innerframe,
+            text="Next",
+            command=self.__next__,
+            width="10",
+            borderwidth=1,
+            highlightthickness=1,
+            state="disabled",
+        )
+        next.pack(side="right", anchor="center")
+        innerframe.pack(side="top", fill="y")
+        self.reset_current_page()
+
+    def reset_current_page(self):
+        self.current_page = -1
+
+    def _poll(self):
+        try:
+            event = self.queue.get(block=False)
+        except q.Empty:
+            pass
+        else:
+            if event == CORPUS_LOADED_EVENT:
+                self.handle_corpus_loaded(event)
+            elif event == ERROR_LOADING_CORPUS_EVENT:
+                self.handle_error_loading_corpus(event)
+        self.after = self.top.after(POLL_INTERVAL, self._poll)
+
+    def handle_error_loading_corpus(self, event):
+        self.status["text"] = "Error in loading " + self.var.get()
+        self.unfreeze_editable()
+        self.clear_results_box()
+        self.freeze_editable()
+        self.reset_current_page()
+
+    def handle_corpus_loaded(self, event):
+        self.status["text"] = self.var.get() + " is loaded"
+        self.unfreeze_editable()
+        self.clear_results_box()
+        self.reset_current_page()
+        # self.next()
+        collocations = self.model.next(self.current_page + 1)
+        self.write_results(collocations)
+        self.current_page += 1
+
+    def corpus_selected(self, *args):
+        new_selection = self.var.get()
+        self.load_corpus(new_selection)
+
+    def previous(self):
+        self.freeze_editable()
+        collocations = self.model.prev(self.current_page - 1)
+        self.current_page = self.current_page - 1
+        self.clear_results_box()
+        self.write_results(collocations)
+        self.unfreeze_editable()
+
+    def __next__(self):
+        self.freeze_editable()
+        collocations = self.model.next(self.current_page + 1)
+        self.clear_results_box()
+        self.write_results(collocations)
+        self.current_page += 1
+        self.unfreeze_editable()
+
+    def load_corpus(self, selection):
+        if self.model.selected_corpus != selection:
+            self.status["text"] = "Loading " + selection + "..."
+            self.freeze_editable()
+            self.model.load_corpus(selection)
+
+    def freeze_editable(self):
+        self.prev["state"] = "disabled"
+        self.next["state"] = "disabled"
+
+    def clear_results_box(self):
+        self.results_box["state"] = "normal"
+        self.results_box.delete("1.0", END)
+        self.results_box["state"] = "disabled"
+
+    def fire_event(self, event):
+        # Firing an event so that rendering of widgets happen in the mainloop thread
+        self.top.event_generate(event, when="tail")
+
+    def destroy(self, *e):
+        if self.top is None:
+            return
+        self.top.after_cancel(self.after)
+        self.top.destroy()
+        self.top = None
+
+    def mainloop(self, *args, **kwargs):
+        if in_idle():
+            return
+        self.top.mainloop(*args, **kwargs)
+
+    def unfreeze_editable(self):
+        self.set_paging_button_states()
+
+    def set_paging_button_states(self):
+        if self.current_page == -1 or self.current_page == 0:
+            self.prev["state"] = "disabled"
+        else:
+            self.prev["state"] = "normal"
+        if self.model.is_last_page(self.current_page):
+            self.next["state"] = "disabled"
+        else:
+            self.next["state"] = "normal"
+
+    def write_results(self, results):
+        self.results_box["state"] = "normal"
+        row = 1
+        for each in results:
+            self.results_box.insert(str(row) + ".0", each[0] + " " + each[1] + "\n")
+            row += 1
+        self.results_box["state"] = "disabled"
+
+
+class CollocationsModel:
+    def __init__(self, queue):
+        self.result_count = None
+        self.selected_corpus = None
+        self.collocations = None
+        self.CORPORA = _CORPORA
+        self.DEFAULT_CORPUS = _DEFAULT
+        self.queue = queue
+        self.reset_results()
+
+    def reset_results(self):
+        self.result_pages = []
+        self.results_returned = 0
+
+    def load_corpus(self, name):
+        self.selected_corpus = name
+        self.collocations = None
+        runner_thread = self.LoadCorpus(name, self)
+        runner_thread.start()
+        self.reset_results()
+
+    def non_default_corpora(self):
+        copy = []
+        copy.extend(list(self.CORPORA.keys()))
+        copy.remove(self.DEFAULT_CORPUS)
+        copy.sort()
+        return copy
+
+    def is_last_page(self, number):
+        if number < len(self.result_pages):
+            return False
+        return self.results_returned + (
+            number - len(self.result_pages)
+        ) * self.result_count >= len(self.collocations)
+
+    def next(self, page):
+        if (len(self.result_pages) - 1) < page:
+            for i in range(page - (len(self.result_pages) - 1)):
+                self.result_pages.append(
+                    self.collocations[
+                        self.results_returned : self.results_returned
+                        + self.result_count
+                    ]
+                )
+                self.results_returned += self.result_count
+        return self.result_pages[page]
+
+    def prev(self, page):
+        if page == -1:
+            return []
+        return self.result_pages[page]
+
+    class LoadCorpus(threading.Thread):
+        def __init__(self, name, model):
+            threading.Thread.__init__(self)
+            self.model, self.name = model, name
+
+        def run(self):
+            try:
+                words = self.model.CORPORA[self.name]()
+                from operator import itemgetter
+
+                text = [w for w in words if len(w) > 2]
+                fd = FreqDist(tuple(text[i : i + 2]) for i in range(len(text) - 1))
+                vocab = FreqDist(text)
+                scored = [
+                    ((w1, w2), fd[(w1, w2)] ** 3 / (vocab[w1] * vocab[w2]))
+                    for w1, w2 in fd
+                ]
+                scored.sort(key=itemgetter(1), reverse=True)
+                self.model.collocations = list(map(itemgetter(0), scored))
+                self.model.queue.put(CORPUS_LOADED_EVENT)
+            except Exception as e:
+                print(e)
+                self.model.queue.put(ERROR_LOADING_CORPUS_EVENT)
+
+
+# def collocations():
+#    colloc_strings = [w1 + ' ' + w2 for w1, w2 in self._collocations[:num]]
+
+
+def app():
+    c = CollocationsView()
+    c.mainloop()
+
+
+if __name__ == "__main__":
+    app()
+
+__all__ = ["app"]

env-llmeval/lib/python3.10/site-packages/nltk/app/concordance_app.py

@@ -0,0 +1,709 @@
+# Natural Language Toolkit: Concordance Application
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Sumukh Ghodke <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import queue as q
+import re
+import threading
+from tkinter import (
+    END,
+    LEFT,
+    SUNKEN,
+    Button,
+    Entry,
+    Frame,
+    IntVar,
+    Label,
+    Menu,
+    OptionMenu,
+    Scrollbar,
+    StringVar,
+    Text,
+    Tk,
+)
+from tkinter.font import Font
+
+from nltk.corpus import (
+    alpino,
+    brown,
+    cess_cat,
+    cess_esp,
+    floresta,
+    indian,
+    mac_morpho,
+    nps_chat,
+    sinica_treebank,
+    treebank,
+)
+from nltk.draw.util import ShowText
+from nltk.util import in_idle
+
+WORD_OR_TAG = "[^/ ]+"
+BOUNDARY = r"\b"
+
+CORPUS_LOADED_EVENT = "<<CL_EVENT>>"
+SEARCH_TERMINATED_EVENT = "<<ST_EVENT>>"
+SEARCH_ERROR_EVENT = "<<SE_EVENT>>"
+ERROR_LOADING_CORPUS_EVENT = "<<ELC_EVENT>>"
+
+POLL_INTERVAL = 50
+
+# NB All corpora must be specified in a lambda expression so as not to be
+# loaded when the module is imported.
+
+_DEFAULT = "English: Brown Corpus (Humor, simplified)"
+_CORPORA = {
+    "Catalan: CESS-CAT Corpus (simplified)": lambda: cess_cat.tagged_sents(
+        tagset="universal"
+    ),
+    "English: Brown Corpus": lambda: brown.tagged_sents(),
+    "English: Brown Corpus (simplified)": lambda: brown.tagged_sents(
+        tagset="universal"
+    ),
+    "English: Brown Corpus (Press, simplified)": lambda: brown.tagged_sents(
+        categories=["news", "editorial", "reviews"], tagset="universal"
+    ),
+    "English: Brown Corpus (Religion, simplified)": lambda: brown.tagged_sents(
+        categories="religion", tagset="universal"
+    ),
+    "English: Brown Corpus (Learned, simplified)": lambda: brown.tagged_sents(
+        categories="learned", tagset="universal"
+    ),
+    "English: Brown Corpus (Science Fiction, simplified)": lambda: brown.tagged_sents(
+        categories="science_fiction", tagset="universal"
+    ),
+    "English: Brown Corpus (Romance, simplified)": lambda: brown.tagged_sents(
+        categories="romance", tagset="universal"
+    ),
+    "English: Brown Corpus (Humor, simplified)": lambda: brown.tagged_sents(
+        categories="humor", tagset="universal"
+    ),
+    "English: NPS Chat Corpus": lambda: nps_chat.tagged_posts(),
+    "English: NPS Chat Corpus (simplified)": lambda: nps_chat.tagged_posts(
+        tagset="universal"
+    ),
+    "English: Wall Street Journal Corpus": lambda: treebank.tagged_sents(),
+    "English: Wall Street Journal Corpus (simplified)": lambda: treebank.tagged_sents(
+        tagset="universal"
+    ),
+    "Chinese: Sinica Corpus": lambda: sinica_treebank.tagged_sents(),
+    "Chinese: Sinica Corpus (simplified)": lambda: sinica_treebank.tagged_sents(
+        tagset="universal"
+    ),
+    "Dutch: Alpino Corpus": lambda: alpino.tagged_sents(),
+    "Dutch: Alpino Corpus (simplified)": lambda: alpino.tagged_sents(
+        tagset="universal"
+    ),
+    "Hindi: Indian Languages Corpus": lambda: indian.tagged_sents(files="hindi.pos"),
+    "Hindi: Indian Languages Corpus (simplified)": lambda: indian.tagged_sents(
+        files="hindi.pos", tagset="universal"
+    ),
+    "Portuguese: Floresta Corpus (Portugal)": lambda: floresta.tagged_sents(),
+    "Portuguese: Floresta Corpus (Portugal, simplified)": lambda: floresta.tagged_sents(
+        tagset="universal"
+    ),
+    "Portuguese: MAC-MORPHO Corpus (Brazil)": lambda: mac_morpho.tagged_sents(),
+    "Portuguese: MAC-MORPHO Corpus (Brazil, simplified)": lambda: mac_morpho.tagged_sents(
+        tagset="universal"
+    ),
+    "Spanish: CESS-ESP Corpus (simplified)": lambda: cess_esp.tagged_sents(
+        tagset="universal"
+    ),
+}
+
+
+class ConcordanceSearchView:
+    _BACKGROUND_COLOUR = "#FFF"  # white
+
+    # Colour of highlighted results
+    _HIGHLIGHT_WORD_COLOUR = "#F00"  # red
+    _HIGHLIGHT_WORD_TAG = "HL_WRD_TAG"
+
+    _HIGHLIGHT_LABEL_COLOUR = "#C0C0C0"  # dark grey
+    _HIGHLIGHT_LABEL_TAG = "HL_LBL_TAG"
+
+    # Percentage of text left of the scrollbar position
+    _FRACTION_LEFT_TEXT = 0.30
+
+    def __init__(self):
+        self.queue = q.Queue()
+        self.model = ConcordanceSearchModel(self.queue)
+        self.top = Tk()
+        self._init_top(self.top)
+        self._init_menubar()
+        self._init_widgets(self.top)
+        self.load_corpus(self.model.DEFAULT_CORPUS)
+        self.after = self.top.after(POLL_INTERVAL, self._poll)
+
+    def _init_top(self, top):
+        top.geometry("950x680+50+50")
+        top.title("NLTK Concordance Search")
+        top.bind("<Control-q>", self.destroy)
+        top.protocol("WM_DELETE_WINDOW", self.destroy)
+        top.minsize(950, 680)
+
+    def _init_widgets(self, parent):
+        self.main_frame = Frame(
+            parent, dict(background=self._BACKGROUND_COLOUR, padx=1, pady=1, border=1)
+        )
+        self._init_corpus_select(self.main_frame)
+        self._init_query_box(self.main_frame)
+        self._init_results_box(self.main_frame)
+        self._init_paging(self.main_frame)
+        self._init_status(self.main_frame)
+        self.main_frame.pack(fill="both", expand=True)
+
+    def _init_menubar(self):
+        self._result_size = IntVar(self.top)
+        self._cntx_bf_len = IntVar(self.top)
+        self._cntx_af_len = IntVar(self.top)
+        menubar = Menu(self.top)
+
+        filemenu = Menu(menubar, tearoff=0, borderwidth=0)
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-q"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        editmenu = Menu(menubar, tearoff=0)
+        rescntmenu = Menu(editmenu, tearoff=0)
+        rescntmenu.add_radiobutton(
+            label="20",
+            variable=self._result_size,
+            underline=0,
+            value=20,
+            command=self.set_result_size,
+        )
+        rescntmenu.add_radiobutton(
+            label="50",
+            variable=self._result_size,
+            underline=0,
+            value=50,
+            command=self.set_result_size,
+        )
+        rescntmenu.add_radiobutton(
+            label="100",
+            variable=self._result_size,
+            underline=0,
+            value=100,
+            command=self.set_result_size,
+        )
+        rescntmenu.invoke(1)
+        editmenu.add_cascade(label="Result Count", underline=0, menu=rescntmenu)
+
+        cntxmenu = Menu(editmenu, tearoff=0)
+        cntxbfmenu = Menu(cntxmenu, tearoff=0)
+        cntxbfmenu.add_radiobutton(
+            label="60 characters",
+            variable=self._cntx_bf_len,
+            underline=0,
+            value=60,
+            command=self.set_cntx_bf_len,
+        )
+        cntxbfmenu.add_radiobutton(
+            label="80 characters",
+            variable=self._cntx_bf_len,
+            underline=0,
+            value=80,
+            command=self.set_cntx_bf_len,
+        )
+        cntxbfmenu.add_radiobutton(
+            label="100 characters",
+            variable=self._cntx_bf_len,
+            underline=0,
+            value=100,
+            command=self.set_cntx_bf_len,
+        )
+        cntxbfmenu.invoke(1)
+        cntxmenu.add_cascade(label="Before", underline=0, menu=cntxbfmenu)
+
+        cntxafmenu = Menu(cntxmenu, tearoff=0)
+        cntxafmenu.add_radiobutton(
+            label="70 characters",
+            variable=self._cntx_af_len,
+            underline=0,
+            value=70,
+            command=self.set_cntx_af_len,
+        )
+        cntxafmenu.add_radiobutton(
+            label="90 characters",
+            variable=self._cntx_af_len,
+            underline=0,
+            value=90,
+            command=self.set_cntx_af_len,
+        )
+        cntxafmenu.add_radiobutton(
+            label="110 characters",
+            variable=self._cntx_af_len,
+            underline=0,
+            value=110,
+            command=self.set_cntx_af_len,
+        )
+        cntxafmenu.invoke(1)
+        cntxmenu.add_cascade(label="After", underline=0, menu=cntxafmenu)
+
+        editmenu.add_cascade(label="Context", underline=0, menu=cntxmenu)
+
+        menubar.add_cascade(label="Edit", underline=0, menu=editmenu)
+
+        self.top.config(menu=menubar)
+
+    def set_result_size(self, **kwargs):
+        self.model.result_count = self._result_size.get()
+
+    def set_cntx_af_len(self, **kwargs):
+        self._char_after = self._cntx_af_len.get()
+
+    def set_cntx_bf_len(self, **kwargs):
+        self._char_before = self._cntx_bf_len.get()
+
+    def _init_corpus_select(self, parent):
+        innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
+        self.var = StringVar(innerframe)
+        self.var.set(self.model.DEFAULT_CORPUS)
+        Label(
+            innerframe,
+            justify=LEFT,
+            text=" Corpus: ",
+            background=self._BACKGROUND_COLOUR,
+            padx=2,
+            pady=1,
+            border=0,
+        ).pack(side="left")
+
+        other_corpora = list(self.model.CORPORA.keys()).remove(
+            self.model.DEFAULT_CORPUS
+        )
+        om = OptionMenu(
+            innerframe,
+            self.var,
+            self.model.DEFAULT_CORPUS,
+            command=self.corpus_selected,
+            *self.model.non_default_corpora()
+        )
+        om["borderwidth"] = 0
+        om["highlightthickness"] = 1
+        om.pack(side="left")
+        innerframe.pack(side="top", fill="x", anchor="n")
+
+    def _init_status(self, parent):
+        self.status = Label(
+            parent,
+            justify=LEFT,
+            relief=SUNKEN,
+            background=self._BACKGROUND_COLOUR,
+            border=0,
+            padx=1,
+            pady=0,
+        )
+        self.status.pack(side="top", anchor="sw")
+
+    def _init_query_box(self, parent):
+        innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
+        another = Frame(innerframe, background=self._BACKGROUND_COLOUR)
+        self.query_box = Entry(another, width=60)
+        self.query_box.pack(side="left", fill="x", pady=25, anchor="center")
+        self.search_button = Button(
+            another,
+            text="Search",
+            command=self.search,
+            borderwidth=1,
+            highlightthickness=1,
+        )
+        self.search_button.pack(side="left", fill="x", pady=25, anchor="center")
+        self.query_box.bind("<KeyPress-Return>", self.search_enter_keypress_handler)
+        another.pack()
+        innerframe.pack(side="top", fill="x", anchor="n")
+
+    def search_enter_keypress_handler(self, *event):
+        self.search()
+
+    def _init_results_box(self, parent):
+        innerframe = Frame(parent)
+        i1 = Frame(innerframe)
+        i2 = Frame(innerframe)
+        vscrollbar = Scrollbar(i1, borderwidth=1)
+        hscrollbar = Scrollbar(i2, borderwidth=1, orient="horiz")
+        self.results_box = Text(
+            i1,
+            font=Font(family="courier", size="16"),
+            state="disabled",
+            borderwidth=1,
+            yscrollcommand=vscrollbar.set,
+            xscrollcommand=hscrollbar.set,
+            wrap="none",
+            width="40",
+            height="20",
+            exportselection=1,
+        )
+        self.results_box.pack(side="left", fill="both", expand=True)
+        self.results_box.tag_config(
+            self._HIGHLIGHT_WORD_TAG, foreground=self._HIGHLIGHT_WORD_COLOUR
+        )
+        self.results_box.tag_config(
+            self._HIGHLIGHT_LABEL_TAG, foreground=self._HIGHLIGHT_LABEL_COLOUR
+        )
+        vscrollbar.pack(side="left", fill="y", anchor="e")
+        vscrollbar.config(command=self.results_box.yview)
+        hscrollbar.pack(side="left", fill="x", expand=True, anchor="w")
+        hscrollbar.config(command=self.results_box.xview)
+        # there is no other way of avoiding the overlap of scrollbars while using pack layout manager!!!
+        Label(i2, text="   ", background=self._BACKGROUND_COLOUR).pack(
+            side="left", anchor="e"
+        )
+        i1.pack(side="top", fill="both", expand=True, anchor="n")
+        i2.pack(side="bottom", fill="x", anchor="s")
+        innerframe.pack(side="top", fill="both", expand=True)
+
+    def _init_paging(self, parent):
+        innerframe = Frame(parent, background=self._BACKGROUND_COLOUR)
+        self.prev = prev = Button(
+            innerframe,
+            text="Previous",
+            command=self.previous,
+            width="10",
+            borderwidth=1,
+            highlightthickness=1,
+            state="disabled",
+        )
+        prev.pack(side="left", anchor="center")
+        self.next = next = Button(
+            innerframe,
+            text="Next",
+            command=self.__next__,
+            width="10",
+            borderwidth=1,
+            highlightthickness=1,
+            state="disabled",
+        )
+        next.pack(side="right", anchor="center")
+        innerframe.pack(side="top", fill="y")
+        self.current_page = 0
+
+    def previous(self):
+        self.clear_results_box()
+        self.freeze_editable()
+        self.model.prev(self.current_page - 1)
+
+    def __next__(self):
+        self.clear_results_box()
+        self.freeze_editable()
+        self.model.next(self.current_page + 1)
+
+    def about(self, *e):
+        ABOUT = "NLTK Concordance Search Demo\n"
+        TITLE = "About: NLTK Concordance Search Demo"
+        try:
+            from tkinter.messagebox import Message
+
+            Message(message=ABOUT, title=TITLE, parent=self.main_frame).show()
+        except:
+            ShowText(self.top, TITLE, ABOUT)
+
+    def _bind_event_handlers(self):
+        self.top.bind(CORPUS_LOADED_EVENT, self.handle_corpus_loaded)
+        self.top.bind(SEARCH_TERMINATED_EVENT, self.handle_search_terminated)
+        self.top.bind(SEARCH_ERROR_EVENT, self.handle_search_error)
+        self.top.bind(ERROR_LOADING_CORPUS_EVENT, self.handle_error_loading_corpus)
+
+    def _poll(self):
+        try:
+            event = self.queue.get(block=False)
+        except q.Empty:
+            pass
+        else:
+            if event == CORPUS_LOADED_EVENT:
+                self.handle_corpus_loaded(event)
+            elif event == SEARCH_TERMINATED_EVENT:
+                self.handle_search_terminated(event)
+            elif event == SEARCH_ERROR_EVENT:
+                self.handle_search_error(event)
+            elif event == ERROR_LOADING_CORPUS_EVENT:
+                self.handle_error_loading_corpus(event)
+        self.after = self.top.after(POLL_INTERVAL, self._poll)
+
+    def handle_error_loading_corpus(self, event):
+        self.status["text"] = "Error in loading " + self.var.get()
+        self.unfreeze_editable()
+        self.clear_all()
+        self.freeze_editable()
+
+    def handle_corpus_loaded(self, event):
+        self.status["text"] = self.var.get() + " is loaded"
+        self.unfreeze_editable()
+        self.clear_all()
+        self.query_box.focus_set()
+
+    def handle_search_terminated(self, event):
+        # todo: refactor the model such that it is less state sensitive
+        results = self.model.get_results()
+        self.write_results(results)
+        self.status["text"] = ""
+        if len(results) == 0:
+            self.status["text"] = "No results found for " + self.model.query
+        else:
+            self.current_page = self.model.last_requested_page
+        self.unfreeze_editable()
+        self.results_box.xview_moveto(self._FRACTION_LEFT_TEXT)
+
+    def handle_search_error(self, event):
+        self.status["text"] = "Error in query " + self.model.query
+        self.unfreeze_editable()
+
+    def corpus_selected(self, *args):
+        new_selection = self.var.get()
+        self.load_corpus(new_selection)
+
+    def load_corpus(self, selection):
+        if self.model.selected_corpus != selection:
+            self.status["text"] = "Loading " + selection + "..."
+            self.freeze_editable()
+            self.model.load_corpus(selection)
+
+    def search(self):
+        self.current_page = 0
+        self.clear_results_box()
+        self.model.reset_results()
+        query = self.query_box.get()
+        if len(query.strip()) == 0:
+            return
+        self.status["text"] = "Searching for " + query
+        self.freeze_editable()
+        self.model.search(query, self.current_page + 1)
+
+    def write_results(self, results):
+        self.results_box["state"] = "normal"
+        row = 1
+        for each in results:
+            sent, pos1, pos2 = each[0].strip(), each[1], each[2]
+            if len(sent) != 0:
+                if pos1 < self._char_before:
+                    sent, pos1, pos2 = self.pad(sent, pos1, pos2)
+                sentence = sent[pos1 - self._char_before : pos1 + self._char_after]
+                if not row == len(results):
+                    sentence += "\n"
+                self.results_box.insert(str(row) + ".0", sentence)
+                word_markers, label_markers = self.words_and_labels(sent, pos1, pos2)
+                for marker in word_markers:
+                    self.results_box.tag_add(
+                        self._HIGHLIGHT_WORD_TAG,
+                        str(row) + "." + str(marker[0]),
+                        str(row) + "." + str(marker[1]),
+                    )
+                for marker in label_markers:
+                    self.results_box.tag_add(
+                        self._HIGHLIGHT_LABEL_TAG,
+                        str(row) + "." + str(marker[0]),
+                        str(row) + "." + str(marker[1]),
+                    )
+                row += 1
+        self.results_box["state"] = "disabled"
+
+    def words_and_labels(self, sentence, pos1, pos2):
+        search_exp = sentence[pos1:pos2]
+        words, labels = [], []
+        labeled_words = search_exp.split(" ")
+        index = 0
+        for each in labeled_words:
+            if each == "":
+                index += 1
+            else:
+                word, label = each.split("/")
+                words.append(
+                    (self._char_before + index, self._char_before + index + len(word))
+                )
+                index += len(word) + 1
+                labels.append(
+                    (self._char_before + index, self._char_before + index + len(label))
+                )
+                index += len(label)
+            index += 1
+        return words, labels
+
+    def pad(self, sent, hstart, hend):
+        if hstart >= self._char_before:
+            return sent, hstart, hend
+        d = self._char_before - hstart
+        sent = "".join([" "] * d) + sent
+        return sent, hstart + d, hend + d
+
+    def destroy(self, *e):
+        if self.top is None:
+            return
+        self.top.after_cancel(self.after)
+        self.top.destroy()
+        self.top = None
+
+    def clear_all(self):
+        self.query_box.delete(0, END)
+        self.model.reset_query()
+        self.clear_results_box()
+
+    def clear_results_box(self):
+        self.results_box["state"] = "normal"
+        self.results_box.delete("1.0", END)
+        self.results_box["state"] = "disabled"
+
+    def freeze_editable(self):
+        self.query_box["state"] = "disabled"
+        self.search_button["state"] = "disabled"
+        self.prev["state"] = "disabled"
+        self.next["state"] = "disabled"
+
+    def unfreeze_editable(self):
+        self.query_box["state"] = "normal"
+        self.search_button["state"] = "normal"
+        self.set_paging_button_states()
+
+    def set_paging_button_states(self):
+        if self.current_page == 0 or self.current_page == 1:
+            self.prev["state"] = "disabled"
+        else:
+            self.prev["state"] = "normal"
+        if self.model.has_more_pages(self.current_page):
+            self.next["state"] = "normal"
+        else:
+            self.next["state"] = "disabled"
+
+    def fire_event(self, event):
+        # Firing an event so that rendering of widgets happen in the mainloop thread
+        self.top.event_generate(event, when="tail")
+
+    def mainloop(self, *args, **kwargs):
+        if in_idle():
+            return
+        self.top.mainloop(*args, **kwargs)
+
+
+class ConcordanceSearchModel:
+    def __init__(self, queue):
+        self.queue = queue
+        self.CORPORA = _CORPORA
+        self.DEFAULT_CORPUS = _DEFAULT
+        self.selected_corpus = None
+        self.reset_query()
+        self.reset_results()
+        self.result_count = None
+        self.last_sent_searched = 0
+
+    def non_default_corpora(self):
+        copy = []
+        copy.extend(list(self.CORPORA.keys()))
+        copy.remove(self.DEFAULT_CORPUS)
+        copy.sort()
+        return copy
+
+    def load_corpus(self, name):
+        self.selected_corpus = name
+        self.tagged_sents = []
+        runner_thread = self.LoadCorpus(name, self)
+        runner_thread.start()
+
+    def search(self, query, page):
+        self.query = query
+        self.last_requested_page = page
+        self.SearchCorpus(self, page, self.result_count).start()
+
+    def next(self, page):
+        self.last_requested_page = page
+        if len(self.results) < page:
+            self.search(self.query, page)
+        else:
+            self.queue.put(SEARCH_TERMINATED_EVENT)
+
+    def prev(self, page):
+        self.last_requested_page = page
+        self.queue.put(SEARCH_TERMINATED_EVENT)
+
+    def reset_results(self):
+        self.last_sent_searched = 0
+        self.results = []
+        self.last_page = None
+
+    def reset_query(self):
+        self.query = None
+
+    def set_results(self, page, resultset):
+        self.results.insert(page - 1, resultset)
+
+    def get_results(self):
+        return self.results[self.last_requested_page - 1]
+
+    def has_more_pages(self, page):
+        if self.results == [] or self.results[0] == []:
+            return False
+        if self.last_page is None:
+            return True
+        return page < self.last_page
+
+    class LoadCorpus(threading.Thread):
+        def __init__(self, name, model):
+            threading.Thread.__init__(self)
+            self.model, self.name = model, name
+
+        def run(self):
+            try:
+                ts = self.model.CORPORA[self.name]()
+                self.model.tagged_sents = [
+                    " ".join(w + "/" + t for (w, t) in sent) for sent in ts
+                ]
+                self.model.queue.put(CORPUS_LOADED_EVENT)
+            except Exception as e:
+                print(e)
+                self.model.queue.put(ERROR_LOADING_CORPUS_EVENT)
+
+    class SearchCorpus(threading.Thread):
+        def __init__(self, model, page, count):
+            self.model, self.count, self.page = model, count, page
+            threading.Thread.__init__(self)
+
+        def run(self):
+            q = self.processed_query()
+            sent_pos, i, sent_count = [], 0, 0
+            for sent in self.model.tagged_sents[self.model.last_sent_searched :]:
+                try:
+                    m = re.search(q, sent)
+                except re.error:
+                    self.model.reset_results()
+                    self.model.queue.put(SEARCH_ERROR_EVENT)
+                    return
+                if m:
+                    sent_pos.append((sent, m.start(), m.end()))
+                    i += 1
+                    if i > self.count:
+                        self.model.last_sent_searched += sent_count - 1
+                        break
+                sent_count += 1
+            if self.count >= len(sent_pos):
+                self.model.last_sent_searched += sent_count - 1
+                self.model.last_page = self.page
+                self.model.set_results(self.page, sent_pos)
+            else:
+                self.model.set_results(self.page, sent_pos[:-1])
+            self.model.queue.put(SEARCH_TERMINATED_EVENT)
+
+        def processed_query(self):
+            new = []
+            for term in self.model.query.split():
+                term = re.sub(r"\.", r"[^/ ]", term)
+                if re.match("[A-Z]+$", term):
+                    new.append(BOUNDARY + WORD_OR_TAG + "/" + term + BOUNDARY)
+                elif "/" in term:
+                    new.append(BOUNDARY + term + BOUNDARY)
+                else:
+                    new.append(BOUNDARY + term + "/" + WORD_OR_TAG + BOUNDARY)
+            return " ".join(new)
+
+
+def app():
+    d = ConcordanceSearchView()
+    d.mainloop()
+
+
+if __name__ == "__main__":
+    app()
+
+__all__ = ["app"]

env-llmeval/lib/python3.10/site-packages/nltk/app/nemo_app.py

@@ -0,0 +1,163 @@
+# Finding (and Replacing) Nemo, Version 1.1, Aristide Grange 2006/06/06
+# https://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/496783
+
+"""
+Finding (and Replacing) Nemo
+
+Instant Regular Expressions
+Created by Aristide Grange
+"""
+import itertools
+import re
+from tkinter import SEL_FIRST, SEL_LAST, Frame, Label, PhotoImage, Scrollbar, Text, Tk
+
+windowTitle = "Finding (and Replacing) Nemo"
+initialFind = r"n(.*?)e(.*?)m(.*?)o"
+initialRepl = r"M\1A\2K\3I"
+initialText = """\
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
+Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
+Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+"""
+images = {
+    "FIND": "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",
+    "find": "R0lGODlhMAAiAPQAMf////f39+/v7+fn597e3tbW1s7OzsbGxr29vbW1ta2traWlpZycnJSUlIyMjISEhHt7e3Nzc2tra2NjY1paWlJSUkpKSkJCQjk5OSkpKRgYGAAAAAAAAAAAAAAAAAAAACH+AS4ALAAAAAAwACIAAAX/ICCOZGmeaKquY2AGLiuvMCAUBuHWc48Kh0iFInEYCb4kSQCxPBiMxkMigRQEgJiSFVBYHNGG0RiZOHjblWAiiY4fkDhEYoBp06dAWfyAQyKAgAwDaHgnB0RwgYASgQ0IhDuGJDAIFhMRVFSLEX8QCJJ4AQM5AgQHTZqqjBAOCQQEkWkCDRMUFQsICQ4Vm5maEwwHOAsPDTpKMAsUDlO4CssTcb+2DAp8YGCyNFoCEsZwFQ3QDRTTVBRS0g1QbgsCd5QAAwgIBwYFAwStzQ8UEdCKVchky0yVBw7YuXkAKt4IAg74vXHVagqFBRgXSCAyYWAVCH0SNhDTitCJfSL5/4RbAPKPhQYYjVCYYAvCP0BxEDaD8CheAAHNwqh8MMGPSwgLeJWhwHSjqkYI+xg4MMCEgQjtRvZ7UAYCpghMF7CxONOWJkYR+rCpY4JlVpVxKDwYWEactKW9mhYRtqCTgwgWEMArERSK1j5q//6T8KXonFsShpiJkAECgQYVjykooCVA0JGHEWNiYCHThTFeb3UkoiCCBgwGEKQ1kuAJlhFwhA71h5SukwUM5qqeCSGBgicEWkfNiWSERtBad4JNIBaQBaQah1ToyGZBAnsIuIJs1qnqiAIVjIE2gnAB1T5x0icgzXT79ipgMOOEH6HBbREBMJCeGEY08IoLAkzB1YYFwjxwSUGSNULQJnNUwRYlCcyEkALIxECAP9cNMMABYpRhy3ZsSLDaR70oUAiABGCkAxowCGCAAfDYIQACXoElGRsdXWDBdg2Y90IWktDYGYAB9PWHP0PMdFZaF07SQgAFNDAMAQg0QA1UC8xoZQl22JGFPgWkOUCOL1pZQyhjxinnnCWEAAA7",
+    "REPL": "R0lGODlhMAAjAPcAMf/////3//+lOf+UKf+MEPf///f39/f35/fv7/ecQvecOfecKfeUIfeUGPeUEPeUCPeMAO/37+/v9+/v3u/n3u/n1u+9jO+9c++1hO+ta++tY++tWu+tUu+tSu+lUu+lQu+lMe+UMe+UKe+UGO+UEO+UAO+MCOfv5+fvxufn7+fn5+fnzue9lOe9c+e1jOe1e+e1c+e1a+etWuetUuelQuecOeeUUueUCN7e597e3t7e1t7ezt7evd7Wzt7Oxt7Ovd7Otd7Opd7OnN7Gtd7Gpd69lN61hN6ta96lStbextberdbW3tbWztbWxtbOvdbOrda1hNalUtaECM7W1s7Ozs7Oxs7Otc7Gxs7Gvc69tc69rc69pc61jM6lc8bWlMbOvcbGxsbGpca9tca9pca1nMaMAL3OhL3Gtb21vb21tb2tpb2tnL2tlLW9tbW9pbW9e7W1pbWtjLWcKa21nK2tra2tnK2tlK2lpa2llK2ljK2le6WlnKWljKWUe6WUc6WUY5y1QpyclJycjJychJyUc5yMY5StY5SUe5SMhJSMe5SMc5SMWpSEa5SESoyUe4yMhIyEY4SlKYScWoSMe4SEe4SEa4R7c4R7Y3uMY3uEe3t7e3t7c3tza3tzY3trKXtjIXOcAHOUMXOEY3Nzc3NzWnNrSmulCGuUMWuMGGtzWmtrY2taMWtaGGOUOWOMAGNzUmNjWmNjSmNaUmNaQmNaOWNaIWNSCFqcAFpjUlpSMVpSIVpSEFpKKVKMAFJSUlJSSlJSMVJKMVJKGFJKAFI5CEqUAEqEAEpzQkpKIUpCQkpCGEpCAEo5EEoxAEJjOUJCOUJCAEI5IUIxADl7ADlaITlCOTkxMTkxKTkxEDkhADFzADFrGDE5OTExADEpEClrCCkxKSkpKSkpISkpACkhCCkhACkYACFzACFrACEhCCEYGBhjEBhjABghABgYCBgYABgQEBgQABAQABAIAAhjAAhSAAhKAAgIEAgICABaAABCAAAhAAAQAAAIAAAAAAAAACH+AS4ALAAAAAAwACMAAAj/AAEIHEiwoMGDCBMqXMiwocOHAA4cgEixIIIJO3JMmAjADIqKFU/8MHIkg5EgYXx4iaTkI0iHE6wE2TCggYILQayEAgXIy8uGCKz8sDCAQAMRG3iEcXULlJkJPwli3OFjh9UdYYLE6NBhA04UXHoVA2XoTZgfPKBWlOBDphAWOdfMcfMDLloeO3hIMjbWVCQ5Fn6E2UFxgpsgFjYIEBADrZU6luqEEfqjTqpt54z1uuWqTIcgWAk7PECGzIUQDRosDmxlUrVJkwQJkqVuX71v06YZcyUlROAdbnLAJKPFyAYFAhoMwFlnEh0rWkpz8raPHm7dqKKc/KFFkBUrVn1M/ziBcEIeLUEQI8/AYk0i9Be4sqjsrN66c9/OnbobhpR3HkIUoZ0WVnBE0AGLFKKFD0HAFUQe77HQgQI1hRBDEHMcY0899bBzihZuCPILJD8EccEGGzwAQhFaUHHQH82sUkgeNHISDBk8WCCCcsqFUEQWmOyzjz3sUGNNOO5Y48YOEgowAAQhnBScQV00k82V47jzjy9CXZBcjziFoco//4CDiSOyhPMPLkJZkEBqJmRQxA9uZGEQD8Ncmc044/zzDF2IZQBCCDYE8QMZz/iiCSx0neHGI7BIhhhNn+1gxRpokEcQAp7seWU7/PwTyxqG/iCEEVzQmUombnDRxRExzP9nBR2PCKLFD3UJwcMPa/SRqUGNWJmNOVn+M44ukMRB4KGcWDNLVhuUMEIJAlzwA3DJBHMJIXm4sQYhqyxCRQQGLSIsn1qac2UzysQSyzX/hLMGD0F0IMCODYAQBA9W/PKPOcRiw0wzwxTiokF9dLMnuv/Mo+fCZF7jBr0xbDDCACWEYKgb1vzjDp/jZNOMLX0IZxAKq2TZTjtaOjwOsXyG+s8sZJTIQsUdIGHoJPf8w487QI/TDSt5mGwQFZxc406o8HiDJchk/ltLHpSlJwSvz5DpTjvmuGNOM57koelBOaAhiCaaPBLL0wwbm003peRBnBZqJMJL1ECz/HXYYx/NdAIOOVCxQyLorswymU93o0wuwfAiTDNR/xz0MLXU0XdCE+UwSTRZAq2lsSATu+4wkGvt+TjNzPLrQyegAUku2Hij5cd8LhxyM8QIg4w18HgcdC6BTBFSDmfQqsovttveDcG7lFLHI75cE841sARCxeWsnxC4G9HADPK6ywzDCRqBo0EHHWhMgT1IJzziNci1N7PMKnSYfML96/90AiJKey/0KtbLX1QK0rrNnQ541xugQ7SHhkXBghN0SKACWRc4KlAhBwKcIOYymJCAAAA7",
+    "repl": "R0lGODlhMAAjAPQAMf////f39+/v7+fn597e3tbW1s7OzsbGxr29vbW1ta2traWlpZycnJSUlIyMjISEhHt7e3Nzc2tra2NjY1paWlJSUkpKSkJCQjk5OTExMSkpKSEhIRgYGBAQEAgICAAAACH+AS4ALAAAAAAwACMAAAX/ICCOZGmeaKqubOu+gCDANBkIQ1EMQhAghFptYEAkEgjEwXBo7ISvweGgWCwUysPjwTgEoCafTySYIhYMxgLBjEQgCULvCw0QdAZdoVhUIJUFChISEAxYeQM1N1OMTAp+UwZ5eA4TEhFbDWYFdC4ECVMJjwl5BwsQa0umEhUVlhESDgqlBp0rAn5nVpBMDxeZDRQbHBgWFBSWDgtLBnFjKwRYCI9VqQsPs0YKEcMXFq0UEalFDWx4BAO2IwPjppAKDkrTWKYUGd7fEJJFEZpM00cOzCgh4EE8SaoWxKNixQooBRMyZMBwAYIRBhUgLDGS4MoBJeoANMhAgQsaCRZm/5lqaCUJhA4cNHjDoKEDBlJUHqkBlYBTiQUZNGjYMMxDhY3VWk6R4MEDBoMUak5AqoYBqANIBo4wcGGDUKIeLlzVZmWJggsVIkwAZaQSA3kdZzlKkIiEAAlDvW5oOkEBs488JTw44oeUIwdvVTFTUK7uiAAPgubt8GFDhQepqETAQCFU1UMGzlqAgFhUsAcCS0AO6lUDhw8xNRSbENGDhgWSHjWUe6ACbKITizmopZoBa6KvOwj9uuHDhwxyj3xekgDDhw5EvWKo0IB4iQLCOCC/njc7ZQ8UeGvza+ABZZgcxJNc4FO1gc0cOsCUrHevc8tdIMTIAhc4F198G2Qwwd8CBIQUAwEINABBBJUwR9R5wElgVRLwWODBBx4cGB8GEzDQIAo33CGJA8gh+JoH/clUgQU0YvDhdfmJdwEFC6Sjgg8yEPAABsPkh2F22cl2AQbn6QdTghTQ5eAJAQyQAAQV0MSBB9gRVZ4GE1mw5JZOAmiAVi1UWcAZDrDyZXYTeaOhA/bIVuIBPtKQ4h7ViYekUPdcEAEbzTzCRp5CADmAAwj+ORGPBcgwAAHo9ABGCYtm0ChwFHShlRiXhmHlkAcCiOeUodqQw5W0oXLAiamy4MOkjOyAaqxUymApDCEAADs=",
+}
+colors = ["#FF7B39", "#80F121"]
+emphColors = ["#DAFC33", "#F42548"]
+fieldParams = {
+    "height": 3,
+    "width": 70,
+    "font": ("monaco", 14),
+    "highlightthickness": 0,
+    "borderwidth": 0,
+    "background": "white",
+}
+textParams = {
+    "bg": "#F7E0D4",
+    "fg": "#2321F1",
+    "highlightthickness": 0,
+    "width": 1,
+    "height": 10,
+    "font": ("verdana", 16),
+    "wrap": "word",
+}
+
+
+class Zone:
+    def __init__(self, image, initialField, initialText):
+        frm = Frame(root)
+        frm.config(background="white")
+        self.image = PhotoImage(format="gif", data=images[image.upper()])
+        self.imageDimmed = PhotoImage(format="gif", data=images[image])
+        self.img = Label(frm)
+        self.img.config(borderwidth=0)
+        self.img.pack(side="left")
+        self.fld = Text(frm, **fieldParams)
+        self.initScrollText(frm, self.fld, initialField)
+        frm = Frame(root)
+        self.txt = Text(frm, **textParams)
+        self.initScrollText(frm, self.txt, initialText)
+        for i in range(2):
+            self.txt.tag_config(colors[i], background=colors[i])
+            self.txt.tag_config("emph" + colors[i], foreground=emphColors[i])
+
+    def initScrollText(self, frm, txt, contents):
+        scl = Scrollbar(frm)
+        scl.config(command=txt.yview)
+        scl.pack(side="right", fill="y")
+        txt.pack(side="left", expand=True, fill="x")
+        txt.config(yscrollcommand=scl.set)
+        txt.insert("1.0", contents)
+        frm.pack(fill="x")
+        Frame(height=2, bd=1, relief="ridge").pack(fill="x")
+
+    def refresh(self):
+        self.colorCycle = itertools.cycle(colors)
+        try:
+            self.substitute()
+            self.img.config(image=self.image)
+        except re.error:
+            self.img.config(image=self.imageDimmed)
+
+
+class FindZone(Zone):
+    def addTags(self, m):
+        color = next(self.colorCycle)
+        self.txt.tag_add(color, "1.0+%sc" % m.start(), "1.0+%sc" % m.end())
+        try:
+            self.txt.tag_add(
+                "emph" + color, "1.0+%sc" % m.start("emph"), "1.0+%sc" % m.end("emph")
+            )
+        except:
+            pass
+
+    def substitute(self, *args):
+        for color in colors:
+            self.txt.tag_remove(color, "1.0", "end")
+            self.txt.tag_remove("emph" + color, "1.0", "end")
+        self.rex = re.compile("")  # default value in case of malformed regexp
+        self.rex = re.compile(self.fld.get("1.0", "end")[:-1], re.MULTILINE)
+        try:
+            re.compile("(?P<emph>%s)" % self.fld.get(SEL_FIRST, SEL_LAST))
+            self.rexSel = re.compile(
+                "%s(?P<emph>%s)%s"
+                % (
+                    self.fld.get("1.0", SEL_FIRST),
+                    self.fld.get(SEL_FIRST, SEL_LAST),
+                    self.fld.get(SEL_LAST, "end")[:-1],
+                ),
+                re.MULTILINE,
+            )
+        except:
+            self.rexSel = self.rex
+        self.rexSel.sub(self.addTags, self.txt.get("1.0", "end"))
+
+
+class ReplaceZone(Zone):
+    def addTags(self, m):
+        s = sz.rex.sub(self.repl, m.group())
+        self.txt.delete(
+            "1.0+%sc" % (m.start() + self.diff), "1.0+%sc" % (m.end() + self.diff)
+        )
+        self.txt.insert("1.0+%sc" % (m.start() + self.diff), s, next(self.colorCycle))
+        self.diff += len(s) - (m.end() - m.start())
+
+    def substitute(self):
+        self.txt.delete("1.0", "end")
+        self.txt.insert("1.0", sz.txt.get("1.0", "end")[:-1])
+        self.diff = 0
+        self.repl = rex0.sub(r"\\g<\1>", self.fld.get("1.0", "end")[:-1])
+        sz.rex.sub(self.addTags, sz.txt.get("1.0", "end")[:-1])
+
+
+def launchRefresh(_):
+    sz.fld.after_idle(sz.refresh)
+    rz.fld.after_idle(rz.refresh)
+
+
+def app():
+    global root, sz, rz, rex0
+    root = Tk()
+    root.resizable(height=False, width=True)
+    root.title(windowTitle)
+    root.minsize(width=250, height=0)
+    sz = FindZone("find", initialFind, initialText)
+    sz.fld.bind("<Button-1>", launchRefresh)
+    sz.fld.bind("<ButtonRelease-1>", launchRefresh)
+    sz.fld.bind("<B1-Motion>", launchRefresh)
+    sz.rexSel = re.compile("")
+    rz = ReplaceZone("repl", initialRepl, "")
+    rex0 = re.compile(r"(?<!\\)\\([0-9]+)")
+    root.bind_all("<Key>", launchRefresh)
+    launchRefresh(None)
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    app()
+
+__all__ = ["app"]

env-llmeval/lib/python3.10/site-packages/nltk/app/rdparser_app.py

@@ -0,0 +1,1052 @@
+# Natural Language Toolkit: Recursive Descent Parser Application
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A graphical tool for exploring the recursive descent parser.
+
+The recursive descent parser maintains a tree, which records the
+structure of the portion of the text that has been parsed.  It uses
+CFG productions to expand the fringe of the tree, and matches its
+leaves against the text.  Initially, the tree contains the start
+symbol ("S").  It is shown in the main canvas, to the right of the
+list of available expansions.
+
+The parser builds up a tree structure for the text using three
+operations:
+
+  - "expand" uses a CFG production to add children to a node on the
+    fringe of the tree.
+  - "match" compares a leaf in the tree to a text token.
+  - "backtrack" returns the tree to its state before the most recent
+    expand or match operation.
+
+The parser maintains a list of tree locations called a "frontier" to
+remember which nodes have not yet been expanded and which leaves have
+not yet been matched against the text.  The leftmost frontier node is
+shown in green, and the other frontier nodes are shown in blue.  The
+parser always performs expand and match operations on the leftmost
+element of the frontier.
+
+You can control the parser's operation by using the "expand," "match,"
+and "backtrack" buttons; or you can use the "step" button to let the
+parser automatically decide which operation to apply.  The parser uses
+the following rules to decide which operation to apply:
+
+  - If the leftmost frontier element is a token, try matching it.
+  - If the leftmost frontier element is a node, try expanding it with
+    the first untried expansion.
+  - Otherwise, backtrack.
+
+The "expand" button applies the untried expansion whose CFG production
+is listed earliest in the grammar.  To manually choose which expansion
+to apply, click on a CFG production from the list of available
+expansions, on the left side of the main window.
+
+The "autostep" button will let the parser continue applying
+applications to the tree until it reaches a complete parse.  You can
+cancel an autostep in progress at any time by clicking on the
+"autostep" button again.
+
+Keyboard Shortcuts::
+      [Space]\t Perform the next expand, match, or backtrack operation
+      [a]\t Step through operations until the next complete parse
+      [e]\t Perform an expand operation
+      [m]\t Perform a match operation
+      [b]\t Perform a backtrack operation
+      [Delete]\t Reset the parser
+      [g]\t Show/hide available expansions list
+      [h]\t Help
+      [Ctrl-p]\t Print
+      [q]\t Quit
+"""
+
+from tkinter import Button, Frame, IntVar, Label, Listbox, Menu, Scrollbar, Tk
+from tkinter.font import Font
+
+from nltk.draw import CFGEditor, TreeSegmentWidget, tree_to_treesegment
+from nltk.draw.util import CanvasFrame, EntryDialog, ShowText, TextWidget
+from nltk.parse import SteppingRecursiveDescentParser
+from nltk.tree import Tree
+from nltk.util import in_idle
+
+
+class RecursiveDescentApp:
+    """
+    A graphical tool for exploring the recursive descent parser.  The tool
+    displays the parser's tree and the remaining text, and allows the
+    user to control the parser's operation.  In particular, the user
+    can expand subtrees on the frontier, match tokens on the frontier
+    against the text, and backtrack.  A "step" button simply steps
+    through the parsing process, performing the operations that
+    ``RecursiveDescentParser`` would use.
+    """
+
+    def __init__(self, grammar, sent, trace=0):
+        self._sent = sent
+        self._parser = SteppingRecursiveDescentParser(grammar, trace)
+
+        # Set up the main window.
+        self._top = Tk()
+        self._top.title("Recursive Descent Parser Application")
+
+        # Set up key bindings.
+        self._init_bindings()
+
+        # Initialize the fonts.
+        self._init_fonts(self._top)
+
+        # Animations.  animating_lock is a lock to prevent the demo
+        # from performing new operations while it's animating.
+        self._animation_frames = IntVar(self._top)
+        self._animation_frames.set(5)
+        self._animating_lock = 0
+        self._autostep = 0
+
+        # The user can hide the grammar.
+        self._show_grammar = IntVar(self._top)
+        self._show_grammar.set(1)
+
+        # Create the basic frames.
+        self._init_menubar(self._top)
+        self._init_buttons(self._top)
+        self._init_feedback(self._top)
+        self._init_grammar(self._top)
+        self._init_canvas(self._top)
+
+        # Initialize the parser.
+        self._parser.initialize(self._sent)
+
+        # Resize callback
+        self._canvas.bind("<Configure>", self._configure)
+
+    #########################################
+    ##  Initialization Helpers
+    #########################################
+
+    def _init_fonts(self, root):
+        # See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
+        self._sysfont = Font(font=Button()["font"])
+        root.option_add("*Font", self._sysfont)
+
+        # TWhat's our font size (default=same as sysfont)
+        self._size = IntVar(root)
+        self._size.set(self._sysfont.cget("size"))
+
+        self._boldfont = Font(family="helvetica", weight="bold", size=self._size.get())
+        self._font = Font(family="helvetica", size=self._size.get())
+        if self._size.get() < 0:
+            big = self._size.get() - 2
+        else:
+            big = self._size.get() + 2
+        self._bigfont = Font(family="helvetica", weight="bold", size=big)
+
+    def _init_grammar(self, parent):
+        # Grammar view.
+        self._prodframe = listframe = Frame(parent)
+        self._prodframe.pack(fill="both", side="left", padx=2)
+        self._prodlist_label = Label(
+            self._prodframe, font=self._boldfont, text="Available Expansions"
+        )
+        self._prodlist_label.pack()
+        self._prodlist = Listbox(
+            self._prodframe,
+            selectmode="single",
+            relief="groove",
+            background="white",
+            foreground="#909090",
+            font=self._font,
+            selectforeground="#004040",
+            selectbackground="#c0f0c0",
+        )
+
+        self._prodlist.pack(side="right", fill="both", expand=1)
+
+        self._productions = list(self._parser.grammar().productions())
+        for production in self._productions:
+            self._prodlist.insert("end", ("  %s" % production))
+        self._prodlist.config(height=min(len(self._productions), 25))
+
+        # Add a scrollbar if there are more than 25 productions.
+        if len(self._productions) > 25:
+            listscroll = Scrollbar(self._prodframe, orient="vertical")
+            self._prodlist.config(yscrollcommand=listscroll.set)
+            listscroll.config(command=self._prodlist.yview)
+            listscroll.pack(side="left", fill="y")
+
+        # If they select a production, apply it.
+        self._prodlist.bind("<<ListboxSelect>>", self._prodlist_select)
+
+    def _init_bindings(self):
+        # Key bindings are a good thing.
+        self._top.bind("<Control-q>", self.destroy)
+        self._top.bind("<Control-x>", self.destroy)
+        self._top.bind("<Escape>", self.destroy)
+        self._top.bind("e", self.expand)
+        # self._top.bind('<Alt-e>', self.expand)
+        # self._top.bind('<Control-e>', self.expand)
+        self._top.bind("m", self.match)
+        self._top.bind("<Alt-m>", self.match)
+        self._top.bind("<Control-m>", self.match)
+        self._top.bind("b", self.backtrack)
+        self._top.bind("<Alt-b>", self.backtrack)
+        self._top.bind("<Control-b>", self.backtrack)
+        self._top.bind("<Control-z>", self.backtrack)
+        self._top.bind("<BackSpace>", self.backtrack)
+        self._top.bind("a", self.autostep)
+        # self._top.bind('<Control-a>', self.autostep)
+        self._top.bind("<Control-space>", self.autostep)
+        self._top.bind("<Control-c>", self.cancel_autostep)
+        self._top.bind("<space>", self.step)
+        self._top.bind("<Delete>", self.reset)
+        self._top.bind("<Control-p>", self.postscript)
+        # self._top.bind('<h>', self.help)
+        # self._top.bind('<Alt-h>', self.help)
+        self._top.bind("<Control-h>", self.help)
+        self._top.bind("<F1>", self.help)
+        # self._top.bind('<g>', self.toggle_grammar)
+        # self._top.bind('<Alt-g>', self.toggle_grammar)
+        # self._top.bind('<Control-g>', self.toggle_grammar)
+        self._top.bind("<Control-g>", self.edit_grammar)
+        self._top.bind("<Control-t>", self.edit_sentence)
+
+    def _init_buttons(self, parent):
+        # Set up the frames.
+        self._buttonframe = buttonframe = Frame(parent)
+        buttonframe.pack(fill="none", side="bottom", padx=3, pady=2)
+        Button(
+            buttonframe,
+            text="Step",
+            background="#90c0d0",
+            foreground="black",
+            command=self.step,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Autostep",
+            background="#90c0d0",
+            foreground="black",
+            command=self.autostep,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Expand",
+            underline=0,
+            background="#90f090",
+            foreground="black",
+            command=self.expand,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Match",
+            underline=0,
+            background="#90f090",
+            foreground="black",
+            command=self.match,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Backtrack",
+            underline=0,
+            background="#f0a0a0",
+            foreground="black",
+            command=self.backtrack,
+        ).pack(side="left")
+        # Replace autostep...
+
+    #         self._autostep_button = Button(buttonframe, text='Autostep',
+    #                                        underline=0, command=self.autostep)
+    #         self._autostep_button.pack(side='left')
+
+    def _configure(self, event):
+        self._autostep = 0
+        (x1, y1, x2, y2) = self._cframe.scrollregion()
+        y2 = event.height - 6
+        self._canvas["scrollregion"] = "%d %d %d %d" % (x1, y1, x2, y2)
+        self._redraw()
+
+    def _init_feedback(self, parent):
+        self._feedbackframe = feedbackframe = Frame(parent)
+        feedbackframe.pack(fill="x", side="bottom", padx=3, pady=3)
+        self._lastoper_label = Label(
+            feedbackframe, text="Last Operation:", font=self._font
+        )
+        self._lastoper_label.pack(side="left")
+        lastoperframe = Frame(feedbackframe, relief="sunken", border=1)
+        lastoperframe.pack(fill="x", side="right", expand=1, padx=5)
+        self._lastoper1 = Label(
+            lastoperframe, foreground="#007070", background="#f0f0f0", font=self._font
+        )
+        self._lastoper2 = Label(
+            lastoperframe,
+            anchor="w",
+            width=30,
+            foreground="#004040",
+            background="#f0f0f0",
+            font=self._font,
+        )
+        self._lastoper1.pack(side="left")
+        self._lastoper2.pack(side="left", fill="x", expand=1)
+
+    def _init_canvas(self, parent):
+        self._cframe = CanvasFrame(
+            parent,
+            background="white",
+            # width=525, height=250,
+            closeenough=10,
+            border=2,
+            relief="sunken",
+        )
+        self._cframe.pack(expand=1, fill="both", side="top", pady=2)
+        canvas = self._canvas = self._cframe.canvas()
+
+        # Initially, there's no tree or text
+        self._tree = None
+        self._textwidgets = []
+        self._textline = None
+
+    def _init_menubar(self, parent):
+        menubar = Menu(parent)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(
+            label="Reset Parser", underline=0, command=self.reset, accelerator="Del"
+        )
+        filemenu.add_command(
+            label="Print to Postscript",
+            underline=0,
+            command=self.postscript,
+            accelerator="Ctrl-p",
+        )
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-x"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        editmenu = Menu(menubar, tearoff=0)
+        editmenu.add_command(
+            label="Edit Grammar",
+            underline=5,
+            command=self.edit_grammar,
+            accelerator="Ctrl-g",
+        )
+        editmenu.add_command(
+            label="Edit Text",
+            underline=5,
+            command=self.edit_sentence,
+            accelerator="Ctrl-t",
+        )
+        menubar.add_cascade(label="Edit", underline=0, menu=editmenu)
+
+        rulemenu = Menu(menubar, tearoff=0)
+        rulemenu.add_command(
+            label="Step", underline=1, command=self.step, accelerator="Space"
+        )
+        rulemenu.add_separator()
+        rulemenu.add_command(
+            label="Match", underline=0, command=self.match, accelerator="Ctrl-m"
+        )
+        rulemenu.add_command(
+            label="Expand", underline=0, command=self.expand, accelerator="Ctrl-e"
+        )
+        rulemenu.add_separator()
+        rulemenu.add_command(
+            label="Backtrack", underline=0, command=self.backtrack, accelerator="Ctrl-b"
+        )
+        menubar.add_cascade(label="Apply", underline=0, menu=rulemenu)
+
+        viewmenu = Menu(menubar, tearoff=0)
+        viewmenu.add_checkbutton(
+            label="Show Grammar",
+            underline=0,
+            variable=self._show_grammar,
+            command=self._toggle_grammar,
+        )
+        viewmenu.add_separator()
+        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=12,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Medium",
+            variable=self._size,
+            underline=0,
+            value=14,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Large",
+            variable=self._size,
+            underline=0,
+            value=18,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Huge",
+            variable=self._size,
+            underline=0,
+            value=24,
+            command=self.resize,
+        )
+        menubar.add_cascade(label="View", underline=0, menu=viewmenu)
+
+        animatemenu = Menu(menubar, tearoff=0)
+        animatemenu.add_radiobutton(
+            label="No Animation", underline=0, variable=self._animation_frames, value=0
+        )
+        animatemenu.add_radiobutton(
+            label="Slow Animation",
+            underline=0,
+            variable=self._animation_frames,
+            value=10,
+            accelerator="-",
+        )
+        animatemenu.add_radiobutton(
+            label="Normal Animation",
+            underline=0,
+            variable=self._animation_frames,
+            value=5,
+            accelerator="=",
+        )
+        animatemenu.add_radiobutton(
+            label="Fast Animation",
+            underline=0,
+            variable=self._animation_frames,
+            value=2,
+            accelerator="+",
+        )
+        menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
+
+        helpmenu = Menu(menubar, tearoff=0)
+        helpmenu.add_command(label="About", underline=0, command=self.about)
+        helpmenu.add_command(
+            label="Instructions", underline=0, command=self.help, accelerator="F1"
+        )
+        menubar.add_cascade(label="Help", underline=0, menu=helpmenu)
+
+        parent.config(menu=menubar)
+
+    #########################################
+    ##  Helper
+    #########################################
+
+    def _get(self, widget, treeloc):
+        for i in treeloc:
+            widget = widget.subtrees()[i]
+        if isinstance(widget, TreeSegmentWidget):
+            widget = widget.label()
+        return widget
+
+    #########################################
+    ##  Main draw procedure
+    #########################################
+
+    def _redraw(self):
+        canvas = self._canvas
+
+        # Delete the old tree, widgets, etc.
+        if self._tree is not None:
+            self._cframe.destroy_widget(self._tree)
+        for twidget in self._textwidgets:
+            self._cframe.destroy_widget(twidget)
+        if self._textline is not None:
+            self._canvas.delete(self._textline)
+
+        # Draw the tree.
+        helv = ("helvetica", -self._size.get())
+        bold = ("helvetica", -self._size.get(), "bold")
+        attribs = {
+            "tree_color": "#000000",
+            "tree_width": 2,
+            "node_font": bold,
+            "leaf_font": helv,
+        }
+        tree = self._parser.tree()
+        self._tree = tree_to_treesegment(canvas, tree, **attribs)
+        self._cframe.add_widget(self._tree, 30, 5)
+
+        # Draw the text.
+        helv = ("helvetica", -self._size.get())
+        bottom = y = self._cframe.scrollregion()[3]
+        self._textwidgets = [
+            TextWidget(canvas, word, font=self._font) for word in self._sent
+        ]
+        for twidget in self._textwidgets:
+            self._cframe.add_widget(twidget, 0, 0)
+            twidget.move(0, bottom - twidget.bbox()[3] - 5)
+            y = min(y, twidget.bbox()[1])
+
+        # Draw a line over the text, to separate it from the tree.
+        self._textline = canvas.create_line(-5000, y - 5, 5000, y - 5, dash=".")
+
+        # Highlight appropriate nodes.
+        self._highlight_nodes()
+        self._highlight_prodlist()
+
+        # Make sure the text lines up.
+        self._position_text()
+
+    def _redraw_quick(self):
+        # This should be more-or-less sufficient after an animation.
+        self._highlight_nodes()
+        self._highlight_prodlist()
+        self._position_text()
+
+    def _highlight_nodes(self):
+        # Highlight the list of nodes to be checked.
+        bold = ("helvetica", -self._size.get(), "bold")
+        for treeloc in self._parser.frontier()[:1]:
+            self._get(self._tree, treeloc)["color"] = "#20a050"
+            self._get(self._tree, treeloc)["font"] = bold
+        for treeloc in self._parser.frontier()[1:]:
+            self._get(self._tree, treeloc)["color"] = "#008080"
+
+    def _highlight_prodlist(self):
+        # Highlight the productions that can be expanded.
+        # Boy, too bad tkinter doesn't implement Listbox.itemconfig;
+        # that would be pretty useful here.
+        self._prodlist.delete(0, "end")
+        expandable = self._parser.expandable_productions()
+        untried = self._parser.untried_expandable_productions()
+        productions = self._productions
+        for index in range(len(productions)):
+            if productions[index] in expandable:
+                if productions[index] in untried:
+                    self._prodlist.insert(index, " %s" % productions[index])
+                else:
+                    self._prodlist.insert(index, " %s (TRIED)" % productions[index])
+                self._prodlist.selection_set(index)
+            else:
+                self._prodlist.insert(index, " %s" % productions[index])
+
+    def _position_text(self):
+        # Line up the text widgets that are matched against the tree
+        numwords = len(self._sent)
+        num_matched = numwords - len(self._parser.remaining_text())
+        leaves = self._tree_leaves()[:num_matched]
+        xmax = self._tree.bbox()[0]
+        for i in range(0, len(leaves)):
+            widget = self._textwidgets[i]
+            leaf = leaves[i]
+            widget["color"] = "#006040"
+            leaf["color"] = "#006040"
+            widget.move(leaf.bbox()[0] - widget.bbox()[0], 0)
+            xmax = widget.bbox()[2] + 10
+
+        # Line up the text widgets that are not matched against the tree.
+        for i in range(len(leaves), numwords):
+            widget = self._textwidgets[i]
+            widget["color"] = "#a0a0a0"
+            widget.move(xmax - widget.bbox()[0], 0)
+            xmax = widget.bbox()[2] + 10
+
+        # If we have a complete parse, make everything green :)
+        if self._parser.currently_complete():
+            for twidget in self._textwidgets:
+                twidget["color"] = "#00a000"
+
+        # Move the matched leaves down to the text.
+        for i in range(0, len(leaves)):
+            widget = self._textwidgets[i]
+            leaf = leaves[i]
+            dy = widget.bbox()[1] - leaf.bbox()[3] - 10.0
+            dy = max(dy, leaf.parent().label().bbox()[3] - leaf.bbox()[3] + 10)
+            leaf.move(0, dy)
+
+    def _tree_leaves(self, tree=None):
+        if tree is None:
+            tree = self._tree
+        if isinstance(tree, TreeSegmentWidget):
+            leaves = []
+            for child in tree.subtrees():
+                leaves += self._tree_leaves(child)
+            return leaves
+        else:
+            return [tree]
+
+    #########################################
+    ##  Button Callbacks
+    #########################################
+
+    def destroy(self, *e):
+        self._autostep = 0
+        if self._top is None:
+            return
+        self._top.destroy()
+        self._top = None
+
+    def reset(self, *e):
+        self._autostep = 0
+        self._parser.initialize(self._sent)
+        self._lastoper1["text"] = "Reset Application"
+        self._lastoper2["text"] = ""
+        self._redraw()
+
+    def autostep(self, *e):
+        if self._animation_frames.get() == 0:
+            self._animation_frames.set(2)
+        if self._autostep:
+            self._autostep = 0
+        else:
+            self._autostep = 1
+            self._step()
+
+    def cancel_autostep(self, *e):
+        # self._autostep_button['text'] = 'Autostep'
+        self._autostep = 0
+
+    # Make sure to stop auto-stepping if we get any user input.
+    def step(self, *e):
+        self._autostep = 0
+        self._step()
+
+    def match(self, *e):
+        self._autostep = 0
+        self._match()
+
+    def expand(self, *e):
+        self._autostep = 0
+        self._expand()
+
+    def backtrack(self, *e):
+        self._autostep = 0
+        self._backtrack()
+
+    def _step(self):
+        if self._animating_lock:
+            return
+
+        # Try expanding, matching, and backtracking (in that order)
+        if self._expand():
+            pass
+        elif self._parser.untried_match() and self._match():
+            pass
+        elif self._backtrack():
+            pass
+        else:
+            self._lastoper1["text"] = "Finished"
+            self._lastoper2["text"] = ""
+            self._autostep = 0
+
+        # Check if we just completed a parse.
+        if self._parser.currently_complete():
+            self._autostep = 0
+            self._lastoper2["text"] += "    [COMPLETE PARSE]"
+
+    def _expand(self, *e):
+        if self._animating_lock:
+            return
+        old_frontier = self._parser.frontier()
+        rv = self._parser.expand()
+        if rv is not None:
+            self._lastoper1["text"] = "Expand:"
+            self._lastoper2["text"] = rv
+            self._prodlist.selection_clear(0, "end")
+            index = self._productions.index(rv)
+            self._prodlist.selection_set(index)
+            self._animate_expand(old_frontier[0])
+            return True
+        else:
+            self._lastoper1["text"] = "Expand:"
+            self._lastoper2["text"] = "(all expansions tried)"
+            return False
+
+    def _match(self, *e):
+        if self._animating_lock:
+            return
+        old_frontier = self._parser.frontier()
+        rv = self._parser.match()
+        if rv is not None:
+            self._lastoper1["text"] = "Match:"
+            self._lastoper2["text"] = rv
+            self._animate_match(old_frontier[0])
+            return True
+        else:
+            self._lastoper1["text"] = "Match:"
+            self._lastoper2["text"] = "(failed)"
+            return False
+
+    def _backtrack(self, *e):
+        if self._animating_lock:
+            return
+        if self._parser.backtrack():
+            elt = self._parser.tree()
+            for i in self._parser.frontier()[0]:
+                elt = elt[i]
+            self._lastoper1["text"] = "Backtrack"
+            self._lastoper2["text"] = ""
+            if isinstance(elt, Tree):
+                self._animate_backtrack(self._parser.frontier()[0])
+            else:
+                self._animate_match_backtrack(self._parser.frontier()[0])
+            return True
+        else:
+            self._autostep = 0
+            self._lastoper1["text"] = "Finished"
+            self._lastoper2["text"] = ""
+            return False
+
+    def about(self, *e):
+        ABOUT = (
+            "NLTK Recursive Descent Parser Application\n" + "Written by Edward Loper"
+        )
+        TITLE = "About: Recursive Descent Parser Application"
+        try:
+            from tkinter.messagebox import Message
+
+            Message(message=ABOUT, title=TITLE).show()
+        except:
+            ShowText(self._top, TITLE, ABOUT)
+
+    def help(self, *e):
+        self._autostep = 0
+        # The default font's not very legible; try using 'fixed' instead.
+        try:
+            ShowText(
+                self._top,
+                "Help: Recursive Descent Parser Application",
+                (__doc__ or "").strip(),
+                width=75,
+                font="fixed",
+            )
+        except:
+            ShowText(
+                self._top,
+                "Help: Recursive Descent Parser Application",
+                (__doc__ or "").strip(),
+                width=75,
+            )
+
+    def postscript(self, *e):
+        self._autostep = 0
+        self._cframe.print_to_file()
+
+    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 resize(self, size=None):
+        if size is not None:
+            self._size.set(size)
+        size = self._size.get()
+        self._font.configure(size=-(abs(size)))
+        self._boldfont.configure(size=-(abs(size)))
+        self._sysfont.configure(size=-(abs(size)))
+        self._bigfont.configure(size=-(abs(size + 2)))
+        self._redraw()
+
+    #########################################
+    ##  Expand Production Selection
+    #########################################
+
+    def _toggle_grammar(self, *e):
+        if self._show_grammar.get():
+            self._prodframe.pack(
+                fill="both", side="left", padx=2, after=self._feedbackframe
+            )
+            self._lastoper1["text"] = "Show Grammar"
+        else:
+            self._prodframe.pack_forget()
+            self._lastoper1["text"] = "Hide Grammar"
+        self._lastoper2["text"] = ""
+
+    #     def toggle_grammar(self, *e):
+    #         self._show_grammar = not self._show_grammar
+    #         if self._show_grammar:
+    #             self._prodframe.pack(fill='both', expand='y', side='left',
+    #                                  after=self._feedbackframe)
+    #             self._lastoper1['text'] = 'Show Grammar'
+    #         else:
+    #             self._prodframe.pack_forget()
+    #             self._lastoper1['text'] = 'Hide Grammar'
+    #         self._lastoper2['text'] = ''
+
+    def _prodlist_select(self, event):
+        selection = self._prodlist.curselection()
+        if len(selection) != 1:
+            return
+        index = int(selection[0])
+        old_frontier = self._parser.frontier()
+        production = self._parser.expand(self._productions[index])
+
+        if production:
+            self._lastoper1["text"] = "Expand:"
+            self._lastoper2["text"] = production
+            self._prodlist.selection_clear(0, "end")
+            self._prodlist.selection_set(index)
+            self._animate_expand(old_frontier[0])
+        else:
+            # Reset the production selections.
+            self._prodlist.selection_clear(0, "end")
+            for prod in self._parser.expandable_productions():
+                index = self._productions.index(prod)
+                self._prodlist.selection_set(index)
+
+    #########################################
+    ##  Animation
+    #########################################
+
+    def _animate_expand(self, treeloc):
+        oldwidget = self._get(self._tree, treeloc)
+        oldtree = oldwidget.parent()
+        top = not isinstance(oldtree.parent(), TreeSegmentWidget)
+
+        tree = self._parser.tree()
+        for i in treeloc:
+            tree = tree[i]
+
+        widget = tree_to_treesegment(
+            self._canvas,
+            tree,
+            node_font=self._boldfont,
+            leaf_color="white",
+            tree_width=2,
+            tree_color="white",
+            node_color="white",
+            leaf_font=self._font,
+        )
+        widget.label()["color"] = "#20a050"
+
+        (oldx, oldy) = oldtree.label().bbox()[:2]
+        (newx, newy) = widget.label().bbox()[:2]
+        widget.move(oldx - newx, oldy - newy)
+
+        if top:
+            self._cframe.add_widget(widget, 0, 5)
+            widget.move(30 - widget.label().bbox()[0], 0)
+            self._tree = widget
+        else:
+            oldtree.parent().replace_child(oldtree, widget)
+
+        # Move the children over so they don't overlap.
+        # Line the children up in a strange way.
+        if widget.subtrees():
+            dx = (
+                oldx
+                + widget.label().width() / 2
+                - widget.subtrees()[0].bbox()[0] / 2
+                - widget.subtrees()[0].bbox()[2] / 2
+            )
+            for subtree in widget.subtrees():
+                subtree.move(dx, 0)
+
+        self._makeroom(widget)
+
+        if top:
+            self._cframe.destroy_widget(oldtree)
+        else:
+            oldtree.destroy()
+
+        colors = [
+            "gray%d" % (10 * int(10 * x / self._animation_frames.get()))
+            for x in range(self._animation_frames.get(), 0, -1)
+        ]
+
+        # Move the text string down, if necessary.
+        dy = widget.bbox()[3] + 30 - self._canvas.coords(self._textline)[1]
+        if dy > 0:
+            for twidget in self._textwidgets:
+                twidget.move(0, dy)
+            self._canvas.move(self._textline, 0, dy)
+
+        self._animate_expand_frame(widget, colors)
+
+    def _makeroom(self, treeseg):
+        """
+        Make sure that no sibling tree bbox's overlap.
+        """
+        parent = treeseg.parent()
+        if not isinstance(parent, TreeSegmentWidget):
+            return
+
+        index = parent.subtrees().index(treeseg)
+
+        # Handle siblings to the right
+        rsiblings = parent.subtrees()[index + 1 :]
+        if rsiblings:
+            dx = treeseg.bbox()[2] - rsiblings[0].bbox()[0] + 10
+            for sibling in rsiblings:
+                sibling.move(dx, 0)
+
+        # Handle siblings to the left
+        if index > 0:
+            lsibling = parent.subtrees()[index - 1]
+            dx = max(0, lsibling.bbox()[2] - treeseg.bbox()[0] + 10)
+            treeseg.move(dx, 0)
+
+        # Keep working up the tree.
+        self._makeroom(parent)
+
+    def _animate_expand_frame(self, widget, colors):
+        if len(colors) > 0:
+            self._animating_lock = 1
+            widget["color"] = colors[0]
+            for subtree in widget.subtrees():
+                if isinstance(subtree, TreeSegmentWidget):
+                    subtree.label()["color"] = colors[0]
+                else:
+                    subtree["color"] = colors[0]
+            self._top.after(50, self._animate_expand_frame, widget, colors[1:])
+        else:
+            widget["color"] = "black"
+            for subtree in widget.subtrees():
+                if isinstance(subtree, TreeSegmentWidget):
+                    subtree.label()["color"] = "black"
+                else:
+                    subtree["color"] = "black"
+            self._redraw_quick()
+            widget.label()["color"] = "black"
+            self._animating_lock = 0
+            if self._autostep:
+                self._step()
+
+    def _animate_backtrack(self, treeloc):
+        # Flash red first, if we're animating.
+        if self._animation_frames.get() == 0:
+            colors = []
+        else:
+            colors = ["#a00000", "#000000", "#a00000"]
+        colors += [
+            "gray%d" % (10 * int(10 * x / (self._animation_frames.get())))
+            for x in range(1, self._animation_frames.get() + 1)
+        ]
+
+        widgets = [self._get(self._tree, treeloc).parent()]
+        for subtree in widgets[0].subtrees():
+            if isinstance(subtree, TreeSegmentWidget):
+                widgets.append(subtree.label())
+            else:
+                widgets.append(subtree)
+
+        self._animate_backtrack_frame(widgets, colors)
+
+    def _animate_backtrack_frame(self, widgets, colors):
+        if len(colors) > 0:
+            self._animating_lock = 1
+            for widget in widgets:
+                widget["color"] = colors[0]
+            self._top.after(50, self._animate_backtrack_frame, widgets, colors[1:])
+        else:
+            for widget in widgets[0].subtrees():
+                widgets[0].remove_child(widget)
+                widget.destroy()
+            self._redraw_quick()
+            self._animating_lock = 0
+            if self._autostep:
+                self._step()
+
+    def _animate_match_backtrack(self, treeloc):
+        widget = self._get(self._tree, treeloc)
+        node = widget.parent().label()
+        dy = (node.bbox()[3] - widget.bbox()[1] + 14) / max(
+            1, self._animation_frames.get()
+        )
+        self._animate_match_backtrack_frame(self._animation_frames.get(), widget, dy)
+
+    def _animate_match(self, treeloc):
+        widget = self._get(self._tree, treeloc)
+
+        dy = (self._textwidgets[0].bbox()[1] - widget.bbox()[3] - 10.0) / max(
+            1, self._animation_frames.get()
+        )
+        self._animate_match_frame(self._animation_frames.get(), widget, dy)
+
+    def _animate_match_frame(self, frame, widget, dy):
+        if frame > 0:
+            self._animating_lock = 1
+            widget.move(0, dy)
+            self._top.after(10, self._animate_match_frame, frame - 1, widget, dy)
+        else:
+            widget["color"] = "#006040"
+            self._redraw_quick()
+            self._animating_lock = 0
+            if self._autostep:
+                self._step()
+
+    def _animate_match_backtrack_frame(self, frame, widget, dy):
+        if frame > 0:
+            self._animating_lock = 1
+            widget.move(0, dy)
+            self._top.after(
+                10, self._animate_match_backtrack_frame, frame - 1, widget, dy
+            )
+        else:
+            widget.parent().remove_child(widget)
+            widget.destroy()
+            self._animating_lock = 0
+            if self._autostep:
+                self._step()
+
+    def edit_grammar(self, *e):
+        CFGEditor(self._top, self._parser.grammar(), self.set_grammar)
+
+    def set_grammar(self, grammar):
+        self._parser.set_grammar(grammar)
+        self._productions = list(grammar.productions())
+        self._prodlist.delete(0, "end")
+        for production in self._productions:
+            self._prodlist.insert("end", (" %s" % production))
+
+    def edit_sentence(self, *e):
+        sentence = " ".join(self._sent)
+        title = "Edit Text"
+        instr = "Enter a new sentence to parse."
+        EntryDialog(self._top, sentence, instr, self.set_sentence, title)
+
+    def set_sentence(self, sentence):
+        self._sent = sentence.split()  # [XX] use tagged?
+        self.reset()
+
+
+def app():
+    """
+    Create a recursive descent parser demo, using a simple grammar and
+    text.
+    """
+    from nltk.grammar import CFG
+
+    grammar = CFG.fromstring(
+        """
+    # Grammatical productions.
+        S -> NP VP
+        NP -> Det N PP | Det N
+        VP -> V NP PP | V NP | V
+        PP -> P NP
+    # Lexical productions.
+        NP -> 'I'
+        Det -> 'the' | 'a'
+        N -> 'man' | 'park' | 'dog' | 'telescope'
+        V -> 'ate' | 'saw'
+        P -> 'in' | 'under' | 'with'
+    """
+    )
+
+    sent = "the dog saw a man in the park".split()
+
+    RecursiveDescentApp(grammar, sent).mainloop()
+
+
+if __name__ == "__main__":
+    app()
+
+__all__ = ["app"]

env-llmeval/lib/python3.10/site-packages/nltk/app/srparser_app.py

@@ -0,0 +1,937 @@
+# Natural Language Toolkit: Shift-Reduce Parser Application
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A graphical tool for exploring the shift-reduce parser.
+
+The shift-reduce parser maintains a stack, which records the structure
+of the portion of the text that has been parsed.  The stack is
+initially empty.  Its contents are shown on the left side of the main
+canvas.
+
+On the right side of the main canvas is the remaining text.  This is
+the portion of the text which has not yet been considered by the
+parser.
+
+The parser builds up a tree structure for the text using two
+operations:
+
+  - "shift" moves the first token from the remaining text to the top
+    of the stack.  In the demo, the top of the stack is its right-hand
+    side.
+  - "reduce" uses a grammar production to combine the rightmost stack
+    elements into a single tree token.
+
+You can control the parser's operation by using the "shift" and
+"reduce" buttons; or you can use the "step" button to let the parser
+automatically decide which operation to apply.  The parser uses the
+following rules to decide which operation to apply:
+
+  - Only shift if no reductions are available.
+  - If multiple reductions are available, then apply the reduction
+    whose CFG production is listed earliest in the grammar.
+
+The "reduce" button applies the reduction whose CFG production is
+listed earliest in the grammar.  There are two ways to manually choose
+which reduction to apply:
+
+  - Click on a CFG production from the list of available reductions,
+    on the left side of the main window.  The reduction based on that
+    production will be applied to the top of the stack.
+  - Click on one of the stack elements.  A popup window will appear,
+    containing all available reductions.  Select one, and it will be
+    applied to the top of the stack.
+
+Note that reductions can only be applied to the top of the stack.
+
+Keyboard Shortcuts::
+      [Space]\t Perform the next shift or reduce operation
+      [s]\t Perform a shift operation
+      [r]\t Perform a reduction operation
+      [Ctrl-z]\t Undo most recent operation
+      [Delete]\t Reset the parser
+      [g]\t Show/hide available production list
+      [Ctrl-a]\t Toggle animations
+      [h]\t Help
+      [Ctrl-p]\t Print
+      [q]\t Quit
+
+"""
+
+from tkinter import Button, Frame, IntVar, Label, Listbox, Menu, Scrollbar, Tk
+from tkinter.font import Font
+
+from nltk.draw import CFGEditor, TreeSegmentWidget, tree_to_treesegment
+from nltk.draw.util import CanvasFrame, EntryDialog, ShowText, TextWidget
+from nltk.parse import SteppingShiftReduceParser
+from nltk.tree import Tree
+from nltk.util import in_idle
+
+"""
+Possible future improvements:
+  - button/window to change and/or select text.  Just pop up a window
+    with an entry, and let them modify the text; and then retokenize
+    it?  Maybe give a warning if it contains tokens whose types are
+    not in the grammar.
+  - button/window to change and/or select grammar.  Select from
+    several alternative grammars?  Or actually change the grammar?  If
+    the later, then I'd want to define nltk.draw.cfg, which would be
+    responsible for that.
+"""
+
+
+class ShiftReduceApp:
+    """
+    A graphical tool for exploring the shift-reduce parser.  The tool
+    displays the parser's stack and the remaining text, and allows the
+    user to control the parser's operation.  In particular, the user
+    can shift tokens onto the stack, and can perform reductions on the
+    top elements of the stack.  A "step" button simply steps through
+    the parsing process, performing the operations that
+    ``nltk.parse.ShiftReduceParser`` would use.
+    """
+
+    def __init__(self, grammar, sent, trace=0):
+        self._sent = sent
+        self._parser = SteppingShiftReduceParser(grammar, trace)
+
+        # Set up the main window.
+        self._top = Tk()
+        self._top.title("Shift Reduce Parser Application")
+
+        # Animations.  animating_lock is a lock to prevent the demo
+        # from performing new operations while it's animating.
+        self._animating_lock = 0
+        self._animate = IntVar(self._top)
+        self._animate.set(10)  # = medium
+
+        # The user can hide the grammar.
+        self._show_grammar = IntVar(self._top)
+        self._show_grammar.set(1)
+
+        # Initialize fonts.
+        self._init_fonts(self._top)
+
+        # Set up key bindings.
+        self._init_bindings()
+
+        # Create the basic frames.
+        self._init_menubar(self._top)
+        self._init_buttons(self._top)
+        self._init_feedback(self._top)
+        self._init_grammar(self._top)
+        self._init_canvas(self._top)
+
+        # A popup menu for reducing.
+        self._reduce_menu = Menu(self._canvas, tearoff=0)
+
+        # Reset the demo, and set the feedback frame to empty.
+        self.reset()
+        self._lastoper1["text"] = ""
+
+    #########################################
+    ##  Initialization Helpers
+    #########################################
+
+    def _init_fonts(self, root):
+        # See: <http://www.astro.washington.edu/owen/ROTKFolklore.html>
+        self._sysfont = Font(font=Button()["font"])
+        root.option_add("*Font", self._sysfont)
+
+        # TWhat's our font size (default=same as sysfont)
+        self._size = IntVar(root)
+        self._size.set(self._sysfont.cget("size"))
+
+        self._boldfont = Font(family="helvetica", weight="bold", size=self._size.get())
+        self._font = Font(family="helvetica", size=self._size.get())
+
+    def _init_grammar(self, parent):
+        # Grammar view.
+        self._prodframe = listframe = Frame(parent)
+        self._prodframe.pack(fill="both", side="left", padx=2)
+        self._prodlist_label = Label(
+            self._prodframe, font=self._boldfont, text="Available Reductions"
+        )
+        self._prodlist_label.pack()
+        self._prodlist = Listbox(
+            self._prodframe,
+            selectmode="single",
+            relief="groove",
+            background="white",
+            foreground="#909090",
+            font=self._font,
+            selectforeground="#004040",
+            selectbackground="#c0f0c0",
+        )
+
+        self._prodlist.pack(side="right", fill="both", expand=1)
+
+        self._productions = list(self._parser.grammar().productions())
+        for production in self._productions:
+            self._prodlist.insert("end", (" %s" % production))
+        self._prodlist.config(height=min(len(self._productions), 25))
+
+        # Add a scrollbar if there are more than 25 productions.
+        if 1:  # len(self._productions) > 25:
+            listscroll = Scrollbar(self._prodframe, orient="vertical")
+            self._prodlist.config(yscrollcommand=listscroll.set)
+            listscroll.config(command=self._prodlist.yview)
+            listscroll.pack(side="left", fill="y")
+
+        # If they select a production, apply it.
+        self._prodlist.bind("<<ListboxSelect>>", self._prodlist_select)
+
+        # When they hover over a production, highlight it.
+        self._hover = -1
+        self._prodlist.bind("<Motion>", self._highlight_hover)
+        self._prodlist.bind("<Leave>", self._clear_hover)
+
+    def _init_bindings(self):
+        # Quit
+        self._top.bind("<Control-q>", self.destroy)
+        self._top.bind("<Control-x>", self.destroy)
+        self._top.bind("<Alt-q>", self.destroy)
+        self._top.bind("<Alt-x>", self.destroy)
+
+        # Ops (step, shift, reduce, undo)
+        self._top.bind("<space>", self.step)
+        self._top.bind("<s>", self.shift)
+        self._top.bind("<Alt-s>", self.shift)
+        self._top.bind("<Control-s>", self.shift)
+        self._top.bind("<r>", self.reduce)
+        self._top.bind("<Alt-r>", self.reduce)
+        self._top.bind("<Control-r>", self.reduce)
+        self._top.bind("<Delete>", self.reset)
+        self._top.bind("<u>", self.undo)
+        self._top.bind("<Alt-u>", self.undo)
+        self._top.bind("<Control-u>", self.undo)
+        self._top.bind("<Control-z>", self.undo)
+        self._top.bind("<BackSpace>", self.undo)
+
+        # Misc
+        self._top.bind("<Control-p>", self.postscript)
+        self._top.bind("<Control-h>", self.help)
+        self._top.bind("<F1>", self.help)
+        self._top.bind("<Control-g>", self.edit_grammar)
+        self._top.bind("<Control-t>", self.edit_sentence)
+
+        # Animation speed control
+        self._top.bind("-", lambda e, a=self._animate: a.set(20))
+        self._top.bind("=", lambda e, a=self._animate: a.set(10))
+        self._top.bind("+", lambda e, a=self._animate: a.set(4))
+
+    def _init_buttons(self, parent):
+        # Set up the frames.
+        self._buttonframe = buttonframe = Frame(parent)
+        buttonframe.pack(fill="none", side="bottom")
+        Button(
+            buttonframe,
+            text="Step",
+            background="#90c0d0",
+            foreground="black",
+            command=self.step,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Shift",
+            underline=0,
+            background="#90f090",
+            foreground="black",
+            command=self.shift,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Reduce",
+            underline=0,
+            background="#90f090",
+            foreground="black",
+            command=self.reduce,
+        ).pack(side="left")
+        Button(
+            buttonframe,
+            text="Undo",
+            underline=0,
+            background="#f0a0a0",
+            foreground="black",
+            command=self.undo,
+        ).pack(side="left")
+
+    def _init_menubar(self, parent):
+        menubar = Menu(parent)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(
+            label="Reset Parser", underline=0, command=self.reset, accelerator="Del"
+        )
+        filemenu.add_command(
+            label="Print to Postscript",
+            underline=0,
+            command=self.postscript,
+            accelerator="Ctrl-p",
+        )
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-x"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        editmenu = Menu(menubar, tearoff=0)
+        editmenu.add_command(
+            label="Edit Grammar",
+            underline=5,
+            command=self.edit_grammar,
+            accelerator="Ctrl-g",
+        )
+        editmenu.add_command(
+            label="Edit Text",
+            underline=5,
+            command=self.edit_sentence,
+            accelerator="Ctrl-t",
+        )
+        menubar.add_cascade(label="Edit", underline=0, menu=editmenu)
+
+        rulemenu = Menu(menubar, tearoff=0)
+        rulemenu.add_command(
+            label="Step", underline=1, command=self.step, accelerator="Space"
+        )
+        rulemenu.add_separator()
+        rulemenu.add_command(
+            label="Shift", underline=0, command=self.shift, accelerator="Ctrl-s"
+        )
+        rulemenu.add_command(
+            label="Reduce", underline=0, command=self.reduce, accelerator="Ctrl-r"
+        )
+        rulemenu.add_separator()
+        rulemenu.add_command(
+            label="Undo", underline=0, command=self.undo, accelerator="Ctrl-u"
+        )
+        menubar.add_cascade(label="Apply", underline=0, menu=rulemenu)
+
+        viewmenu = Menu(menubar, tearoff=0)
+        viewmenu.add_checkbutton(
+            label="Show Grammar",
+            underline=0,
+            variable=self._show_grammar,
+            command=self._toggle_grammar,
+        )
+        viewmenu.add_separator()
+        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=12,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Medium",
+            variable=self._size,
+            underline=0,
+            value=14,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Large",
+            variable=self._size,
+            underline=0,
+            value=18,
+            command=self.resize,
+        )
+        viewmenu.add_radiobutton(
+            label="Huge",
+            variable=self._size,
+            underline=0,
+            value=24,
+            command=self.resize,
+        )
+        menubar.add_cascade(label="View", underline=0, menu=viewmenu)
+
+        animatemenu = Menu(menubar, tearoff=0)
+        animatemenu.add_radiobutton(
+            label="No Animation", underline=0, variable=self._animate, value=0
+        )
+        animatemenu.add_radiobutton(
+            label="Slow Animation",
+            underline=0,
+            variable=self._animate,
+            value=20,
+            accelerator="-",
+        )
+        animatemenu.add_radiobutton(
+            label="Normal Animation",
+            underline=0,
+            variable=self._animate,
+            value=10,
+            accelerator="=",
+        )
+        animatemenu.add_radiobutton(
+            label="Fast Animation",
+            underline=0,
+            variable=self._animate,
+            value=4,
+            accelerator="+",
+        )
+        menubar.add_cascade(label="Animate", underline=1, menu=animatemenu)
+
+        helpmenu = Menu(menubar, tearoff=0)
+        helpmenu.add_command(label="About", underline=0, command=self.about)
+        helpmenu.add_command(
+            label="Instructions", underline=0, command=self.help, accelerator="F1"
+        )
+        menubar.add_cascade(label="Help", underline=0, menu=helpmenu)
+
+        parent.config(menu=menubar)
+
+    def _init_feedback(self, parent):
+        self._feedbackframe = feedbackframe = Frame(parent)
+        feedbackframe.pack(fill="x", side="bottom", padx=3, pady=3)
+        self._lastoper_label = Label(
+            feedbackframe, text="Last Operation:", font=self._font
+        )
+        self._lastoper_label.pack(side="left")
+        lastoperframe = Frame(feedbackframe, relief="sunken", border=1)
+        lastoperframe.pack(fill="x", side="right", expand=1, padx=5)
+        self._lastoper1 = Label(
+            lastoperframe, foreground="#007070", background="#f0f0f0", font=self._font
+        )
+        self._lastoper2 = Label(
+            lastoperframe,
+            anchor="w",
+            width=30,
+            foreground="#004040",
+            background="#f0f0f0",
+            font=self._font,
+        )
+        self._lastoper1.pack(side="left")
+        self._lastoper2.pack(side="left", fill="x", expand=1)
+
+    def _init_canvas(self, parent):
+        self._cframe = CanvasFrame(
+            parent,
+            background="white",
+            width=525,
+            closeenough=10,
+            border=2,
+            relief="sunken",
+        )
+        self._cframe.pack(expand=1, fill="both", side="top", pady=2)
+        canvas = self._canvas = self._cframe.canvas()
+
+        self._stackwidgets = []
+        self._rtextwidgets = []
+        self._titlebar = canvas.create_rectangle(
+            0, 0, 0, 0, fill="#c0f0f0", outline="black"
+        )
+        self._exprline = canvas.create_line(0, 0, 0, 0, dash=".")
+        self._stacktop = canvas.create_line(0, 0, 0, 0, fill="#408080")
+        size = self._size.get() + 4
+        self._stacklabel = TextWidget(
+            canvas, "Stack", color="#004040", font=self._boldfont
+        )
+        self._rtextlabel = TextWidget(
+            canvas, "Remaining Text", color="#004040", font=self._boldfont
+        )
+        self._cframe.add_widget(self._stacklabel)
+        self._cframe.add_widget(self._rtextlabel)
+
+    #########################################
+    ##  Main draw procedure
+    #########################################
+
+    def _redraw(self):
+        scrollregion = self._canvas["scrollregion"].split()
+        (cx1, cy1, cx2, cy2) = (int(c) for c in scrollregion)
+
+        # Delete the old stack & rtext widgets.
+        for stackwidget in self._stackwidgets:
+            self._cframe.destroy_widget(stackwidget)
+        self._stackwidgets = []
+        for rtextwidget in self._rtextwidgets:
+            self._cframe.destroy_widget(rtextwidget)
+        self._rtextwidgets = []
+
+        # Position the titlebar & exprline
+        (x1, y1, x2, y2) = self._stacklabel.bbox()
+        y = y2 - y1 + 10
+        self._canvas.coords(self._titlebar, -5000, 0, 5000, y - 4)
+        self._canvas.coords(self._exprline, 0, y * 2 - 10, 5000, y * 2 - 10)
+
+        # Position the titlebar labels..
+        (x1, y1, x2, y2) = self._stacklabel.bbox()
+        self._stacklabel.move(5 - x1, 3 - y1)
+        (x1, y1, x2, y2) = self._rtextlabel.bbox()
+        self._rtextlabel.move(cx2 - x2 - 5, 3 - y1)
+
+        # Draw the stack.
+        stackx = 5
+        for tok in self._parser.stack():
+            if isinstance(tok, Tree):
+                attribs = {
+                    "tree_color": "#4080a0",
+                    "tree_width": 2,
+                    "node_font": self._boldfont,
+                    "node_color": "#006060",
+                    "leaf_color": "#006060",
+                    "leaf_font": self._font,
+                }
+                widget = tree_to_treesegment(self._canvas, tok, **attribs)
+                widget.label()["color"] = "#000000"
+            else:
+                widget = TextWidget(self._canvas, tok, color="#000000", font=self._font)
+            widget.bind_click(self._popup_reduce)
+            self._stackwidgets.append(widget)
+            self._cframe.add_widget(widget, stackx, y)
+            stackx = widget.bbox()[2] + 10
+
+        # Draw the remaining text.
+        rtextwidth = 0
+        for tok in self._parser.remaining_text():
+            widget = TextWidget(self._canvas, tok, color="#000000", font=self._font)
+            self._rtextwidgets.append(widget)
+            self._cframe.add_widget(widget, rtextwidth, y)
+            rtextwidth = widget.bbox()[2] + 4
+
+        # Allow enough room to shift the next token (for animations)
+        if len(self._rtextwidgets) > 0:
+            stackx += self._rtextwidgets[0].width()
+
+        # Move the remaining text to the correct location (keep it
+        # right-justified, when possible); and move the remaining text
+        # label, if necessary.
+        stackx = max(stackx, self._stacklabel.width() + 25)
+        rlabelwidth = self._rtextlabel.width() + 10
+        if stackx >= cx2 - max(rtextwidth, rlabelwidth):
+            cx2 = stackx + max(rtextwidth, rlabelwidth)
+        for rtextwidget in self._rtextwidgets:
+            rtextwidget.move(4 + cx2 - rtextwidth, 0)
+        self._rtextlabel.move(cx2 - self._rtextlabel.bbox()[2] - 5, 0)
+
+        midx = (stackx + cx2 - max(rtextwidth, rlabelwidth)) / 2
+        self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
+        (x1, y1, x2, y2) = self._stacklabel.bbox()
+
+        # Set up binding to allow them to shift a token by dragging it.
+        if len(self._rtextwidgets) > 0:
+
+            def drag_shift(widget, midx=midx, self=self):
+                if widget.bbox()[0] < midx:
+                    self.shift()
+                else:
+                    self._redraw()
+
+            self._rtextwidgets[0].bind_drag(drag_shift)
+            self._rtextwidgets[0].bind_click(self.shift)
+
+        # Draw the stack top.
+        self._highlight_productions()
+
+    def _draw_stack_top(self, widget):
+        # hack..
+        midx = widget.bbox()[2] + 50
+        self._canvas.coords(self._stacktop, midx, 0, midx, 5000)
+
+    def _highlight_productions(self):
+        # Highlight the productions that can be reduced.
+        self._prodlist.selection_clear(0, "end")
+        for prod in self._parser.reducible_productions():
+            index = self._productions.index(prod)
+            self._prodlist.selection_set(index)
+
+    #########################################
+    ##  Button Callbacks
+    #########################################
+
+    def destroy(self, *e):
+        if self._top is None:
+            return
+        self._top.destroy()
+        self._top = None
+
+    def reset(self, *e):
+        self._parser.initialize(self._sent)
+        self._lastoper1["text"] = "Reset App"
+        self._lastoper2["text"] = ""
+        self._redraw()
+
+    def step(self, *e):
+        if self.reduce():
+            return True
+        elif self.shift():
+            return True
+        else:
+            if list(self._parser.parses()):
+                self._lastoper1["text"] = "Finished:"
+                self._lastoper2["text"] = "Success"
+            else:
+                self._lastoper1["text"] = "Finished:"
+                self._lastoper2["text"] = "Failure"
+
+    def shift(self, *e):
+        if self._animating_lock:
+            return
+        if self._parser.shift():
+            tok = self._parser.stack()[-1]
+            self._lastoper1["text"] = "Shift:"
+            self._lastoper2["text"] = "%r" % tok
+            if self._animate.get():
+                self._animate_shift()
+            else:
+                self._redraw()
+            return True
+        return False
+
+    def reduce(self, *e):
+        if self._animating_lock:
+            return
+        production = self._parser.reduce()
+        if production:
+            self._lastoper1["text"] = "Reduce:"
+            self._lastoper2["text"] = "%s" % production
+            if self._animate.get():
+                self._animate_reduce()
+            else:
+                self._redraw()
+        return production
+
+    def undo(self, *e):
+        if self._animating_lock:
+            return
+        if self._parser.undo():
+            self._redraw()
+
+    def postscript(self, *e):
+        self._cframe.print_to_file()
+
+    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)
+
+    #########################################
+    ##  Menubar callbacks
+    #########################################
+
+    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._boldfont.configure(size=-(abs(size)))
+        self._sysfont.configure(size=-(abs(size)))
+
+        # self._stacklabel['font'] = ('helvetica', -size-4, 'bold')
+        # self._rtextlabel['font'] = ('helvetica', -size-4, 'bold')
+        # self._lastoper_label['font'] = ('helvetica', -size)
+        # self._lastoper1['font'] = ('helvetica', -size)
+        # self._lastoper2['font'] = ('helvetica', -size)
+        # self._prodlist['font'] = ('helvetica', -size)
+        # self._prodlist_label['font'] = ('helvetica', -size-2, 'bold')
+        self._redraw()
+
+    def help(self, *e):
+        # The default font's not very legible; try using 'fixed' instead.
+        try:
+            ShowText(
+                self._top,
+                "Help: Shift-Reduce Parser Application",
+                (__doc__ or "").strip(),
+                width=75,
+                font="fixed",
+            )
+        except:
+            ShowText(
+                self._top,
+                "Help: Shift-Reduce Parser Application",
+                (__doc__ or "").strip(),
+                width=75,
+            )
+
+    def about(self, *e):
+        ABOUT = "NLTK Shift-Reduce Parser Application\n" + "Written by Edward Loper"
+        TITLE = "About: Shift-Reduce Parser Application"
+        try:
+            from tkinter.messagebox import Message
+
+            Message(message=ABOUT, title=TITLE).show()
+        except:
+            ShowText(self._top, TITLE, ABOUT)
+
+    def edit_grammar(self, *e):
+        CFGEditor(self._top, self._parser.grammar(), self.set_grammar)
+
+    def set_grammar(self, grammar):
+        self._parser.set_grammar(grammar)
+        self._productions = list(grammar.productions())
+        self._prodlist.delete(0, "end")
+        for production in self._productions:
+            self._prodlist.insert("end", (" %s" % production))
+
+    def edit_sentence(self, *e):
+        sentence = " ".join(self._sent)
+        title = "Edit Text"
+        instr = "Enter a new sentence to parse."
+        EntryDialog(self._top, sentence, instr, self.set_sentence, title)
+
+    def set_sentence(self, sent):
+        self._sent = sent.split()  # [XX] use tagged?
+        self.reset()
+
+    #########################################
+    ##  Reduce Production Selection
+    #########################################
+
+    def _toggle_grammar(self, *e):
+        if self._show_grammar.get():
+            self._prodframe.pack(
+                fill="both", side="left", padx=2, after=self._feedbackframe
+            )
+            self._lastoper1["text"] = "Show Grammar"
+        else:
+            self._prodframe.pack_forget()
+            self._lastoper1["text"] = "Hide Grammar"
+        self._lastoper2["text"] = ""
+
+    def _prodlist_select(self, event):
+        selection = self._prodlist.curselection()
+        if len(selection) != 1:
+            return
+        index = int(selection[0])
+        production = self._parser.reduce(self._productions[index])
+        if production:
+            self._lastoper1["text"] = "Reduce:"
+            self._lastoper2["text"] = "%s" % production
+            if self._animate.get():
+                self._animate_reduce()
+            else:
+                self._redraw()
+        else:
+            # Reset the production selections.
+            self._prodlist.selection_clear(0, "end")
+            for prod in self._parser.reducible_productions():
+                index = self._productions.index(prod)
+                self._prodlist.selection_set(index)
+
+    def _popup_reduce(self, widget):
+        # Remove old commands.
+        productions = self._parser.reducible_productions()
+        if len(productions) == 0:
+            return
+
+        self._reduce_menu.delete(0, "end")
+        for production in productions:
+            self._reduce_menu.add_command(label=str(production), command=self.reduce)
+        self._reduce_menu.post(
+            self._canvas.winfo_pointerx(), self._canvas.winfo_pointery()
+        )
+
+    #########################################
+    ##  Animations
+    #########################################
+
+    def _animate_shift(self):
+        # What widget are we shifting?
+        widget = self._rtextwidgets[0]
+
+        # Where are we shifting from & to?
+        right = widget.bbox()[0]
+        if len(self._stackwidgets) == 0:
+            left = 5
+        else:
+            left = self._stackwidgets[-1].bbox()[2] + 10
+
+        # Start animating.
+        dt = self._animate.get()
+        dx = (left - right) * 1.0 / dt
+        self._animate_shift_frame(dt, widget, dx)
+
+    def _animate_shift_frame(self, frame, widget, dx):
+        if frame > 0:
+            self._animating_lock = 1
+            widget.move(dx, 0)
+            self._top.after(10, self._animate_shift_frame, frame - 1, widget, dx)
+        else:
+            # but: stacktop??
+
+            # Shift the widget to the stack.
+            del self._rtextwidgets[0]
+            self._stackwidgets.append(widget)
+            self._animating_lock = 0
+
+            # Display the available productions.
+            self._draw_stack_top(widget)
+            self._highlight_productions()
+
+    def _animate_reduce(self):
+        # What widgets are we shifting?
+        numwidgets = len(self._parser.stack()[-1])  # number of children
+        widgets = self._stackwidgets[-numwidgets:]
+
+        # How far are we moving?
+        if isinstance(widgets[0], TreeSegmentWidget):
+            ydist = 15 + widgets[0].label().height()
+        else:
+            ydist = 15 + widgets[0].height()
+
+        # Start animating.
+        dt = self._animate.get()
+        dy = ydist * 2.0 / dt
+        self._animate_reduce_frame(dt / 2, widgets, dy)
+
+    def _animate_reduce_frame(self, frame, widgets, dy):
+        if frame > 0:
+            self._animating_lock = 1
+            for widget in widgets:
+                widget.move(0, dy)
+            self._top.after(10, self._animate_reduce_frame, frame - 1, widgets, dy)
+        else:
+            del self._stackwidgets[-len(widgets) :]
+            for widget in widgets:
+                self._cframe.remove_widget(widget)
+            tok = self._parser.stack()[-1]
+            if not isinstance(tok, Tree):
+                raise ValueError()
+            label = TextWidget(
+                self._canvas, str(tok.label()), color="#006060", font=self._boldfont
+            )
+            widget = TreeSegmentWidget(self._canvas, label, widgets, width=2)
+            (x1, y1, x2, y2) = self._stacklabel.bbox()
+            y = y2 - y1 + 10
+            if not self._stackwidgets:
+                x = 5
+            else:
+                x = self._stackwidgets[-1].bbox()[2] + 10
+            self._cframe.add_widget(widget, x, y)
+            self._stackwidgets.append(widget)
+
+            # Display the available productions.
+            self._draw_stack_top(widget)
+            self._highlight_productions()
+
+            #             # Delete the old widgets..
+            #             del self._stackwidgets[-len(widgets):]
+            #             for widget in widgets:
+            #                 self._cframe.destroy_widget(widget)
+            #
+            #             # Make a new one.
+            #             tok = self._parser.stack()[-1]
+            #             if isinstance(tok, Tree):
+            #                 attribs = {'tree_color': '#4080a0', 'tree_width': 2,
+            #                            'node_font': bold, 'node_color': '#006060',
+            #                            'leaf_color': '#006060', 'leaf_font':self._font}
+            #                 widget = tree_to_treesegment(self._canvas, tok.type(),
+            #                                              **attribs)
+            #                 widget.node()['color'] = '#000000'
+            #             else:
+            #                 widget = TextWidget(self._canvas, tok.type(),
+            #                                     color='#000000', font=self._font)
+            #             widget.bind_click(self._popup_reduce)
+            #             (x1, y1, x2, y2) = self._stacklabel.bbox()
+            #             y = y2-y1+10
+            #             if not self._stackwidgets: x = 5
+            #             else: x = self._stackwidgets[-1].bbox()[2] + 10
+            #             self._cframe.add_widget(widget, x, y)
+            #             self._stackwidgets.append(widget)
+
+            # self._redraw()
+            self._animating_lock = 0
+
+    #########################################
+    ##  Hovering.
+    #########################################
+
+    def _highlight_hover(self, event):
+        # What production are we hovering over?
+        index = self._prodlist.nearest(event.y)
+        if self._hover == index:
+            return
+
+        # Clear any previous hover highlighting.
+        self._clear_hover()
+
+        # If the production corresponds to an available reduction,
+        # highlight the stack.
+        selection = [int(s) for s in self._prodlist.curselection()]
+        if index in selection:
+            rhslen = len(self._productions[index].rhs())
+            for stackwidget in self._stackwidgets[-rhslen:]:
+                if isinstance(stackwidget, TreeSegmentWidget):
+                    stackwidget.label()["color"] = "#00a000"
+                else:
+                    stackwidget["color"] = "#00a000"
+
+        # Remember what production we're hovering over.
+        self._hover = index
+
+    def _clear_hover(self, *event):
+        # Clear any previous hover highlighting.
+        if self._hover == -1:
+            return
+        self._hover = -1
+        for stackwidget in self._stackwidgets:
+            if isinstance(stackwidget, TreeSegmentWidget):
+                stackwidget.label()["color"] = "black"
+            else:
+                stackwidget["color"] = "black"
+
+
+def app():
+    """
+    Create a shift reduce parser app, using a simple grammar and
+    text.
+    """
+
+    from nltk.grammar import CFG, Nonterminal, Production
+
+    nonterminals = "S VP NP PP P N Name V Det"
+    (S, VP, NP, PP, P, N, Name, V, Det) = (Nonterminal(s) for s in nonterminals.split())
+
+    productions = (
+        # Syntactic Productions
+        Production(S, [NP, VP]),
+        Production(NP, [Det, N]),
+        Production(NP, [NP, PP]),
+        Production(VP, [VP, PP]),
+        Production(VP, [V, NP, PP]),
+        Production(VP, [V, NP]),
+        Production(PP, [P, NP]),
+        # Lexical Productions
+        Production(NP, ["I"]),
+        Production(Det, ["the"]),
+        Production(Det, ["a"]),
+        Production(N, ["man"]),
+        Production(V, ["saw"]),
+        Production(P, ["in"]),
+        Production(P, ["with"]),
+        Production(N, ["park"]),
+        Production(N, ["dog"]),
+        Production(N, ["statue"]),
+        Production(Det, ["my"]),
+    )
+
+    grammar = CFG(S, productions)
+
+    # tokenize the sentence
+    sent = "my dog saw a man in the park with a statue".split()
+
+    ShiftReduceApp(grammar, sent).mainloop()
+
+
+if __name__ == "__main__":
+    app()
+
+__all__ = ["app"]

env-llmeval/lib/python3.10/site-packages/nltk/app/wordfreq_app.py

@@ -0,0 +1,36 @@
+# Natural Language Toolkit: Wordfreq Application
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Sumukh Ghodke <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from matplotlib import pylab
+
+from nltk.corpus import gutenberg
+from nltk.text import Text
+
+
+def plot_word_freq_dist(text):
+    fd = text.vocab()
+
+    samples = [item for item, _ in fd.most_common(50)]
+    values = [fd[sample] for sample in samples]
+    values = [sum(values[: i + 1]) * 100.0 / fd.N() for i in range(len(values))]
+    pylab.title(text.name)
+    pylab.xlabel("Samples")
+    pylab.ylabel("Cumulative Percentage")
+    pylab.plot(values)
+    pylab.xticks(range(len(samples)), [str(s) for s in samples], rotation=90)
+    pylab.show()
+
+
+def app():
+    t1 = Text(gutenberg.words("melville-moby_dick.txt"))
+    plot_word_freq_dist(t1)
+
+
+if __name__ == "__main__":
+    app()
+
+__all__ = ["app"]

env-llmeval/lib/python3.10/site-packages/nltk/app/wordnet_app.py

@@ -0,0 +1,1005 @@
+# Natural Language Toolkit: WordNet Browser Application
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Jussi Salmela <[email protected]>
+#         Paul Bone <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A WordNet Browser application which launches the default browser
+(if it is not already running) and opens a new tab with a connection
+to http://localhost:port/ .  It also starts an HTTP server on the
+specified port and begins serving browser requests.  The default
+port is 8000.  (For command-line help, run "python wordnet -h")
+This application requires that the user's web browser supports
+Javascript.
+
+BrowServer is a server for browsing the NLTK Wordnet database It first
+launches a browser client to be used for browsing and then starts
+serving the requests of that and maybe other clients
+
+Usage::
+
+    browserver.py -h
+    browserver.py [-s] [-p <port>]
+
+Options::
+
+    -h or --help
+        Display this help message.
+
+    -l <file> or --log-file <file>
+        Logs messages to the given file, If this option is not specified
+        messages are silently dropped.
+
+    -p <port> or --port <port>
+        Run the web server on this TCP port, defaults to 8000.
+
+    -s or --server-mode
+        Do not start a web browser, and do not allow a user to
+        shutdown the server through the web interface.
+"""
+# TODO: throughout this package variable names and docstrings need
+# modifying to be compliant with NLTK's coding standards.  Tests also
+# need to be develop to ensure this continues to work in the face of
+# changes to other NLTK packages.
+
+import base64
+import copy
+import getopt
+import io
+import os
+import pickle
+import sys
+import threading
+import time
+import webbrowser
+from collections import defaultdict
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+# Allow this program to run inside the NLTK source tree.
+from sys import argv
+from urllib.parse import unquote_plus
+
+from nltk.corpus import wordnet as wn
+from nltk.corpus.reader.wordnet import Lemma, Synset
+
+firstClient = True
+
+# True if we're not also running a web browser.  The value f server_mode
+# gets set by demo().
+server_mode = None
+
+# If set this is a file object for writing log messages.
+logfile = None
+
+
+class MyServerHandler(BaseHTTPRequestHandler):
+    def do_HEAD(self):
+        self.send_head()
+
+    def do_GET(self):
+        global firstClient
+        sp = self.path[1:]
+        if unquote_plus(sp) == "SHUTDOWN THE SERVER":
+            if server_mode:
+                page = "Server must be killed with SIGTERM."
+                type = "text/plain"
+            else:
+                print("Server shutting down!")
+                os._exit(0)
+
+        elif sp == "":  # First request.
+            type = "text/html"
+            if not server_mode and firstClient:
+                firstClient = False
+                page = get_static_index_page(True)
+            else:
+                page = get_static_index_page(False)
+            word = "green"
+
+        elif sp.endswith(".html"):  # Trying to fetch a HTML file TODO:
+            type = "text/html"
+            usp = unquote_plus(sp)
+            if usp == "NLTK Wordnet Browser Database Info.html":
+                word = "* Database Info *"
+                if os.path.isfile(usp):
+                    with open(usp) as infile:
+                        page = infile.read()
+                else:
+                    page = (
+                        (html_header % word) + "<p>The database info file:"
+                        "<p><b>"
+                        + usp
+                        + "</b>"
+                        + "<p>was not found. Run this:"
+                        + "<p><b>python dbinfo_html.py</b>"
+                        + "<p>to produce it."
+                        + html_trailer
+                    )
+            else:
+                # Handle files here.
+                word = sp
+                try:
+                    page = get_static_page_by_path(usp)
+                except FileNotFoundError:
+                    page = "Internal error: Path for static page '%s' is unknown" % usp
+                    # Set type to plain to prevent XSS by printing the path as HTML
+                    type = "text/plain"
+        elif sp.startswith("search"):
+            # This doesn't seem to work with MWEs.
+            type = "text/html"
+            parts = (sp.split("?")[1]).split("&")
+            word = [
+                p.split("=")[1].replace("+", " ")
+                for p in parts
+                if p.startswith("nextWord")
+            ][0]
+            page, word = page_from_word(word)
+        elif sp.startswith("lookup_"):
+            # TODO add a variation of this that takes a non ecoded word or MWE.
+            type = "text/html"
+            sp = sp[len("lookup_") :]
+            page, word = page_from_href(sp)
+        elif sp == "start_page":
+            # if this is the first request we should display help
+            # information, and possibly set a default word.
+            type = "text/html"
+            page, word = page_from_word("wordnet")
+        else:
+            type = "text/plain"
+            page = "Could not parse request: '%s'" % sp
+
+        # Send result.
+        self.send_head(type)
+        self.wfile.write(page.encode("utf8"))
+
+    def send_head(self, type=None):
+        self.send_response(200)
+        self.send_header("Content-type", type)
+        self.end_headers()
+
+    def log_message(self, format, *args):
+        global logfile
+
+        if logfile:
+            logfile.write(
+                "%s - - [%s] %s\n"
+                % (self.address_string(), self.log_date_time_string(), format % args)
+            )
+
+
+def get_unique_counter_from_url(sp):
+    """
+    Extract the unique counter from the URL if it has one.  Otherwise return
+    null.
+    """
+    pos = sp.rfind("%23")
+    if pos != -1:
+        return int(sp[(pos + 3) :])
+    else:
+        return None
+
+
+def wnb(port=8000, runBrowser=True, logfilename=None):
+    """
+    Run NLTK Wordnet Browser Server.
+
+    :param port: The port number for the server to listen on, defaults to
+                 8000
+    :type  port: int
+
+    :param runBrowser: True to start a web browser and point it at the web
+                       server.
+    :type  runBrowser: bool
+    """
+    # The webbrowser module is unpredictable, typically it blocks if it uses
+    # a console web browser, and doesn't block if it uses a GUI webbrowser,
+    # so we need to force it to have a clear correct behaviour.
+    #
+    # Normally the server should run for as long as the user wants. they
+    # should idealy be able to control this from the UI by closing the
+    # window or tab.  Second best would be clicking a button to say
+    # 'Shutdown' that first shutsdown the server and closes the window or
+    # tab, or exits the text-mode browser.  Both of these are unfreasable.
+    #
+    # The next best alternative is to start the server, have it close when
+    # it receives SIGTERM (default), and run the browser as well.  The user
+    # may have to shutdown both programs.
+    #
+    # Since webbrowser may block, and the webserver will block, we must run
+    # them in separate threads.
+    #
+    global server_mode, logfile
+    server_mode = not runBrowser
+
+    # Setup logging.
+    if logfilename:
+        try:
+            logfile = open(logfilename, "a", 1)  # 1 means 'line buffering'
+        except OSError as e:
+            sys.stderr.write("Couldn't open %s for writing: %s", logfilename, e)
+            sys.exit(1)
+    else:
+        logfile = None
+
+    # Compute URL and start web browser
+    url = "http://localhost:" + str(port)
+
+    server_ready = None
+    browser_thread = None
+
+    if runBrowser:
+        server_ready = threading.Event()
+        browser_thread = startBrowser(url, server_ready)
+
+    # Start the server.
+    server = HTTPServer(("", port), MyServerHandler)
+    if logfile:
+        logfile.write("NLTK Wordnet browser server running serving: %s\n" % url)
+    if runBrowser:
+        server_ready.set()
+
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+
+    if runBrowser:
+        browser_thread.join()
+
+    if logfile:
+        logfile.close()
+
+
+def startBrowser(url, server_ready):
+    def run():
+        server_ready.wait()
+        time.sleep(1)  # Wait a little bit more, there's still the chance of
+        # a race condition.
+        webbrowser.open(url, new=2, autoraise=1)
+
+    t = threading.Thread(target=run)
+    t.start()
+    return t
+
+
+#####################################################################
+# Utilities
+#####################################################################
+
+
+"""
+WordNet Browser Utilities.
+
+This provides a backend to both wxbrowse and browserver.py.
+"""
+
+################################################################################
+#
+# Main logic for wordnet browser.
+#
+
+# This is wrapped inside a function since wn is only available if the
+# WordNet corpus is installed.
+def _pos_tuples():
+    return [
+        (wn.NOUN, "N", "noun"),
+        (wn.VERB, "V", "verb"),
+        (wn.ADJ, "J", "adj"),
+        (wn.ADV, "R", "adv"),
+    ]
+
+
+def _pos_match(pos_tuple):
+    """
+    This function returns the complete pos tuple for the partial pos
+    tuple given to it.  It attempts to match it against the first
+    non-null component of the given pos tuple.
+    """
+    if pos_tuple[0] == "s":
+        pos_tuple = ("a", pos_tuple[1], pos_tuple[2])
+    for n, x in enumerate(pos_tuple):
+        if x is not None:
+            break
+    for pt in _pos_tuples():
+        if pt[n] == pos_tuple[n]:
+            return pt
+    return None
+
+
+HYPONYM = 0
+HYPERNYM = 1
+CLASS_REGIONAL = 2
+PART_HOLONYM = 3
+PART_MERONYM = 4
+ATTRIBUTE = 5
+SUBSTANCE_HOLONYM = 6
+SUBSTANCE_MERONYM = 7
+MEMBER_HOLONYM = 8
+MEMBER_MERONYM = 9
+VERB_GROUP = 10
+INSTANCE_HYPONYM = 12
+INSTANCE_HYPERNYM = 13
+CAUSE = 14
+ALSO_SEE = 15
+SIMILAR = 16
+ENTAILMENT = 17
+ANTONYM = 18
+FRAMES = 19
+PERTAINYM = 20
+
+CLASS_CATEGORY = 21
+CLASS_USAGE = 22
+CLASS_REGIONAL = 23
+CLASS_USAGE = 24
+CLASS_CATEGORY = 11
+
+DERIVATIONALLY_RELATED_FORM = 25
+
+INDIRECT_HYPERNYMS = 26
+
+
+def lemma_property(word, synset, func):
+    def flattern(l):
+        if l == []:
+            return []
+        else:
+            return l[0] + flattern(l[1:])
+
+    return flattern([func(l) for l in synset.lemmas() if l.name == word])
+
+
+def rebuild_tree(orig_tree):
+    node = orig_tree[0]
+    children = orig_tree[1:]
+    return (node, [rebuild_tree(t) for t in children])
+
+
+def get_relations_data(word, synset):
+    """
+    Get synset relations data for a synset.  Note that this doesn't
+    yet support things such as full hyponym vs direct hyponym.
+    """
+    if synset.pos() == wn.NOUN:
+        return (
+            (HYPONYM, "Hyponyms", synset.hyponyms()),
+            (INSTANCE_HYPONYM, "Instance hyponyms", synset.instance_hyponyms()),
+            (HYPERNYM, "Direct hypernyms", synset.hypernyms()),
+            (
+                INDIRECT_HYPERNYMS,
+                "Indirect hypernyms",
+                rebuild_tree(synset.tree(lambda x: x.hypernyms()))[1],
+            ),
+            #  hypernyms', 'Sister terms',
+            (INSTANCE_HYPERNYM, "Instance hypernyms", synset.instance_hypernyms()),
+            #            (CLASS_REGIONAL, ['domain term region'], ),
+            (PART_HOLONYM, "Part holonyms", synset.part_holonyms()),
+            (PART_MERONYM, "Part meronyms", synset.part_meronyms()),
+            (SUBSTANCE_HOLONYM, "Substance holonyms", synset.substance_holonyms()),
+            (SUBSTANCE_MERONYM, "Substance meronyms", synset.substance_meronyms()),
+            (MEMBER_HOLONYM, "Member holonyms", synset.member_holonyms()),
+            (MEMBER_MERONYM, "Member meronyms", synset.member_meronyms()),
+            (ATTRIBUTE, "Attributes", synset.attributes()),
+            (ANTONYM, "Antonyms", lemma_property(word, synset, lambda l: l.antonyms())),
+            (
+                DERIVATIONALLY_RELATED_FORM,
+                "Derivationally related form",
+                lemma_property(
+                    word, synset, lambda l: l.derivationally_related_forms()
+                ),
+            ),
+        )
+    elif synset.pos() == wn.VERB:
+        return (
+            (ANTONYM, "Antonym", lemma_property(word, synset, lambda l: l.antonyms())),
+            (HYPONYM, "Hyponym", synset.hyponyms()),
+            (HYPERNYM, "Direct hypernyms", synset.hypernyms()),
+            (
+                INDIRECT_HYPERNYMS,
+                "Indirect hypernyms",
+                rebuild_tree(synset.tree(lambda x: x.hypernyms()))[1],
+            ),
+            (ENTAILMENT, "Entailments", synset.entailments()),
+            (CAUSE, "Causes", synset.causes()),
+            (ALSO_SEE, "Also see", synset.also_sees()),
+            (VERB_GROUP, "Verb Groups", synset.verb_groups()),
+            (
+                DERIVATIONALLY_RELATED_FORM,
+                "Derivationally related form",
+                lemma_property(
+                    word, synset, lambda l: l.derivationally_related_forms()
+                ),
+            ),
+        )
+    elif synset.pos() == wn.ADJ or synset.pos == wn.ADJ_SAT:
+        return (
+            (ANTONYM, "Antonym", lemma_property(word, synset, lambda l: l.antonyms())),
+            (SIMILAR, "Similar to", synset.similar_tos()),
+            # Participle of verb - not supported by corpus
+            (
+                PERTAINYM,
+                "Pertainyms",
+                lemma_property(word, synset, lambda l: l.pertainyms()),
+            ),
+            (ATTRIBUTE, "Attributes", synset.attributes()),
+            (ALSO_SEE, "Also see", synset.also_sees()),
+        )
+    elif synset.pos() == wn.ADV:
+        # This is weird. adverbs such as 'quick' and 'fast' don't seem
+        # to have antonyms returned by the corpus.a
+        return (
+            (ANTONYM, "Antonym", lemma_property(word, synset, lambda l: l.antonyms())),
+        )
+        # Derived from adjective - not supported by corpus
+    else:
+        raise TypeError("Unhandles synset POS type: " + str(synset.pos()))
+
+
+html_header = """
+<!DOCTYPE html PUBLIC '-//W3C//DTD HTML 4.01//EN'
+'http://www.w3.org/TR/html4/strict.dtd'>
+<html>
+<head>
+<meta name='generator' content=
+'HTML Tidy for Windows (vers 14 February 2006), see www.w3.org'>
+<meta http-equiv='Content-Type' content=
+'text/html; charset=us-ascii'>
+<title>NLTK Wordnet Browser display of: %s</title></head>
+<body bgcolor='#F5F5F5' text='#000000'>
+"""
+html_trailer = """
+</body>
+</html>
+"""
+
+explanation = """
+<h3>Search Help</h3>
+<ul><li>The display below the line is an example of the output the browser
+shows you when you enter a search word. The search word was <b>green</b>.</li>
+<li>The search result shows for different parts of speech the <b>synsets</b>
+i.e. different meanings for the word.</li>
+<li>All underlined texts are hypertext links. There are two types of links:
+word links and others. Clicking a word link carries out a search for the word
+in the Wordnet database.</li>
+<li>Clicking a link of the other type opens a display section of data attached
+to that link. Clicking that link a second time closes the section again.</li>
+<li>Clicking <u>S:</u> opens a section showing the relations for that synset.
+</li>
+<li>Clicking on a relation name opens a section that displays the associated
+synsets.</li>
+<li>Type a search word in the <b>Word</b> field and start the search by the
+<b>Enter/Return</b> key or click the <b>Search</b> button.</li>
+</ul>
+<hr width='100%'>
+"""
+
+# HTML oriented functions
+
+
+def _bold(txt):
+    return "<b>%s</b>" % txt
+
+
+def _center(txt):
+    return "<center>%s</center>" % txt
+
+
+def _hlev(n, txt):
+    return "<h%d>%s</h%d>" % (n, txt, n)
+
+
+def _italic(txt):
+    return "<i>%s</i>" % txt
+
+
+def _li(txt):
+    return "<li>%s</li>" % txt
+
+
+def pg(word, body):
+    """
+    Return a HTML page of NLTK Browser format constructed from the
+    word and body
+
+    :param word: The word that the body corresponds to
+    :type word: str
+    :param body: The HTML body corresponding to the word
+    :type body: str
+    :return: a HTML page for the word-body combination
+    :rtype: str
+    """
+    return (html_header % word) + body + html_trailer
+
+
+def _ul(txt):
+    return "<ul>" + txt + "</ul>"
+
+
+def _abbc(txt):
+    """
+    abbc = asterisks, breaks, bold, center
+    """
+    return _center(_bold("<br>" * 10 + "*" * 10 + " " + txt + " " + "*" * 10))
+
+
+full_hyponym_cont_text = _ul(_li(_italic("(has full hyponym continuation)"))) + "\n"
+
+
+def _get_synset(synset_key):
+    """
+    The synset key is the unique name of the synset, this can be
+    retrieved via synset.name()
+    """
+    return wn.synset(synset_key)
+
+
+def _collect_one_synset(word, synset, synset_relations):
+    """
+    Returns the HTML string for one synset or word
+
+    :param word: the current word
+    :type word: str
+    :param synset: a synset
+    :type synset: synset
+    :param synset_relations: information about which synset relations
+    to display.
+    :type synset_relations: dict(synset_key, set(relation_id))
+    :return: The HTML string built for this synset
+    :rtype: str
+    """
+    if isinstance(synset, tuple):  # It's a word
+        raise NotImplementedError("word not supported by _collect_one_synset")
+
+    typ = "S"
+    pos_tuple = _pos_match((synset.pos(), None, None))
+    assert pos_tuple is not None, "pos_tuple is null: synset.pos(): %s" % synset.pos()
+    descr = pos_tuple[2]
+    ref = copy.deepcopy(Reference(word, synset_relations))
+    ref.toggle_synset(synset)
+    synset_label = typ + ";"
+    if synset.name() in synset_relations:
+        synset_label = _bold(synset_label)
+    s = f"<li>{make_lookup_link(ref, synset_label)} ({descr}) "
+
+    def format_lemma(w):
+        w = w.replace("_", " ")
+        if w.lower() == word:
+            return _bold(w)
+        else:
+            ref = Reference(w)
+            return make_lookup_link(ref, w)
+
+    s += ", ".join(format_lemma(l.name()) for l in synset.lemmas())
+
+    gl = " ({}) <i>{}</i> ".format(
+        synset.definition(),
+        "; ".join('"%s"' % e for e in synset.examples()),
+    )
+    return s + gl + _synset_relations(word, synset, synset_relations) + "</li>\n"
+
+
+def _collect_all_synsets(word, pos, synset_relations=dict()):
+    """
+    Return a HTML unordered list of synsets for the given word and
+    part of speech.
+    """
+    return "<ul>%s\n</ul>\n" % "".join(
+        _collect_one_synset(word, synset, synset_relations)
+        for synset in wn.synsets(word, pos)
+    )
+
+
+def _synset_relations(word, synset, synset_relations):
+    """
+    Builds the HTML string for the relations of a synset
+
+    :param word: The current word
+    :type word: str
+    :param synset: The synset for which we're building the relations.
+    :type synset: Synset
+    :param synset_relations: synset keys and relation types for which to display relations.
+    :type synset_relations: dict(synset_key, set(relation_type))
+    :return: The HTML for a synset's relations
+    :rtype: str
+    """
+
+    if not synset.name() in synset_relations:
+        return ""
+    ref = Reference(word, synset_relations)
+
+    def relation_html(r):
+        if isinstance(r, Synset):
+            return make_lookup_link(Reference(r.lemma_names()[0]), r.lemma_names()[0])
+        elif isinstance(r, Lemma):
+            return relation_html(r.synset())
+        elif isinstance(r, tuple):
+            # It's probably a tuple containing a Synset and a list of
+            # similar tuples.  This forms a tree of synsets.
+            return "{}\n<ul>{}</ul>\n".format(
+                relation_html(r[0]),
+                "".join("<li>%s</li>\n" % relation_html(sr) for sr in r[1]),
+            )
+        else:
+            raise TypeError(
+                "r must be a synset, lemma or list, it was: type(r) = %s, r = %s"
+                % (type(r), r)
+            )
+
+    def make_synset_html(db_name, disp_name, rels):
+        synset_html = "<i>%s</i>\n" % make_lookup_link(
+            copy.deepcopy(ref).toggle_synset_relation(synset, db_name),
+            disp_name,
+        )
+
+        if db_name in ref.synset_relations[synset.name()]:
+            synset_html += "<ul>%s</ul>\n" % "".join(
+                "<li>%s</li>\n" % relation_html(r) for r in rels
+            )
+
+        return synset_html
+
+    html = (
+        "<ul>"
+        + "\n".join(
+            "<li>%s</li>" % make_synset_html(*rel_data)
+            for rel_data in get_relations_data(word, synset)
+            if rel_data[2] != []
+        )
+        + "</ul>"
+    )
+
+    return html
+
+
+class RestrictedUnpickler(pickle.Unpickler):
+    """
+    Unpickler that prevents any class or function from being used during loading.
+    """
+
+    def find_class(self, module, name):
+        # Forbid every function
+        raise pickle.UnpicklingError(f"global '{module}.{name}' is forbidden")
+
+
+class Reference:
+    """
+    A reference to a page that may be generated by page_word
+    """
+
+    def __init__(self, word, synset_relations=dict()):
+        """
+        Build a reference to a new page.
+
+        word is the word or words (separated by commas) for which to
+        search for synsets of
+
+        synset_relations is a dictionary of synset keys to sets of
+        synset relation identifaiers to unfold a list of synset
+        relations for.
+        """
+        self.word = word
+        self.synset_relations = synset_relations
+
+    def encode(self):
+        """
+        Encode this reference into a string to be used in a URL.
+        """
+        # This uses a tuple rather than an object since the python
+        # pickle representation is much smaller and there is no need
+        # to represent the complete object.
+        string = pickle.dumps((self.word, self.synset_relations), -1)
+        return base64.urlsafe_b64encode(string).decode()
+
+    @staticmethod
+    def decode(string):
+        """
+        Decode a reference encoded with Reference.encode
+        """
+        string = base64.urlsafe_b64decode(string.encode())
+        word, synset_relations = RestrictedUnpickler(io.BytesIO(string)).load()
+        return Reference(word, synset_relations)
+
+    def toggle_synset_relation(self, synset, relation):
+        """
+        Toggle the display of the relations for the given synset and
+        relation type.
+
+        This function will throw a KeyError if the synset is currently
+        not being displayed.
+        """
+        if relation in self.synset_relations[synset.name()]:
+            self.synset_relations[synset.name()].remove(relation)
+        else:
+            self.synset_relations[synset.name()].add(relation)
+
+        return self
+
+    def toggle_synset(self, synset):
+        """
+        Toggle displaying of the relation types for the given synset
+        """
+        if synset.name() in self.synset_relations:
+            del self.synset_relations[synset.name()]
+        else:
+            self.synset_relations[synset.name()] = set()
+
+        return self
+
+
+def make_lookup_link(ref, label):
+    return f'<a href="lookup_{ref.encode()}">{label}</a>'
+
+
+def page_from_word(word):
+    """
+    Return a HTML page for the given word.
+
+    :type word: str
+    :param word: The currently active word
+    :return: A tuple (page,word), where page is the new current HTML page
+        to be sent to the browser and
+        word is the new current word
+    :rtype: A tuple (str,str)
+    """
+    return page_from_reference(Reference(word))
+
+
+def page_from_href(href):
+    """
+    Returns a tuple of the HTML page built and the new current word
+
+    :param href: The hypertext reference to be solved
+    :type href: str
+    :return: A tuple (page,word), where page is the new current HTML page
+             to be sent to the browser and
+             word is the new current word
+    :rtype: A tuple (str,str)
+    """
+    return page_from_reference(Reference.decode(href))
+
+
+def page_from_reference(href):
+    """
+    Returns a tuple of the HTML page built and the new current word
+
+    :param href: The hypertext reference to be solved
+    :type href: str
+    :return: A tuple (page,word), where page is the new current HTML page
+             to be sent to the browser and
+             word is the new current word
+    :rtype: A tuple (str,str)
+    """
+    word = href.word
+    pos_forms = defaultdict(list)
+    words = word.split(",")
+    words = [w for w in [w.strip().lower().replace(" ", "_") for w in words] if w != ""]
+    if len(words) == 0:
+        # No words were found.
+        return "", "Please specify a word to search for."
+
+    # This looks up multiple words at once.  This is probably not
+    # necessary and may lead to problems.
+    for w in words:
+        for pos in [wn.NOUN, wn.VERB, wn.ADJ, wn.ADV]:
+            form = wn.morphy(w, pos)
+            if form and form not in pos_forms[pos]:
+                pos_forms[pos].append(form)
+    body = ""
+    for pos, pos_str, name in _pos_tuples():
+        if pos in pos_forms:
+            body += _hlev(3, name) + "\n"
+            for w in pos_forms[pos]:
+                # Not all words of exc files are in the database, skip
+                # to the next word if a KeyError is raised.
+                try:
+                    body += _collect_all_synsets(w, pos, href.synset_relations)
+                except KeyError:
+                    pass
+    if not body:
+        body = "The word or words '%s' were not found in the dictionary." % word
+    return body, word
+
+
+#####################################################################
+# Static pages
+#####################################################################
+
+
+def get_static_page_by_path(path):
+    """
+    Return a static HTML page from the path given.
+    """
+    if path == "index_2.html":
+        return get_static_index_page(False)
+    elif path == "index.html":
+        return get_static_index_page(True)
+    elif path == "NLTK Wordnet Browser Database Info.html":
+        return "Display of Wordnet Database Statistics is not supported"
+    elif path == "upper_2.html":
+        return get_static_upper_page(False)
+    elif path == "upper.html":
+        return get_static_upper_page(True)
+    elif path == "web_help.html":
+        return get_static_web_help_page()
+    elif path == "wx_help.html":
+        return get_static_wx_help_page()
+    raise FileNotFoundError()
+
+
+def get_static_web_help_page():
+    """
+    Return the static web help page.
+    """
+    return """
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+     <!-- Natural Language Toolkit: Wordnet Interface: Graphical Wordnet Browser
+            Copyright (C) 2001-2023 NLTK Project
+            Author: Jussi Salmela <[email protected]>
+            URL: <https://www.nltk.org/>
+            For license information, see LICENSE.TXT -->
+     <head>
+          <meta http-equiv='Content-Type' content='text/html; charset=us-ascii'>
+          <title>NLTK Wordnet Browser display of: * Help *</title>
+     </head>
+<body bgcolor='#F5F5F5' text='#000000'>
+<h2>NLTK Wordnet Browser Help</h2>
+<p>The NLTK Wordnet Browser is a tool to use in browsing the Wordnet database. It tries to behave like the Wordnet project's web browser but the difference is that the NLTK Wordnet Browser uses a local Wordnet database.
+<p><b>You are using the Javascript client part of the NLTK Wordnet BrowseServer.</b> We assume your browser is in tab sheets enabled mode.</p>
+<p>For background information on Wordnet, see the Wordnet project home page: <a href="https://wordnet.princeton.edu/"><b> https://wordnet.princeton.edu/</b></a>. For more information on the NLTK project, see the project home:
+<a href="https://www.nltk.org/"><b>https://www.nltk.org/</b></a>. To get an idea of what the Wordnet version used by this browser includes choose <b>Show Database Info</b> from the <b>View</b> submenu.</p>
+<h3>Word search</h3>
+<p>The word to be searched is typed into the <b>New Word</b> field and the search started with Enter or by clicking the <b>Search</b> button. There is no uppercase/lowercase distinction: the search word is transformed to lowercase before the search.</p>
+<p>In addition, the word does not have to be in base form. The browser tries to find the possible base form(s) by making certain morphological substitutions. Typing <b>fLIeS</b> as an obscure example gives one <a href="MfLIeS">this</a>. Click the previous link to see what this kind of search looks like and then come back to this page by using the <b>Alt+LeftArrow</b> key combination.</p>
+<p>The result of a search is a display of one or more
+<b>synsets</b> for every part of speech in which a form of the
+search word was found to occur. A synset is a set of words
+having the same sense or meaning. Each word in a synset that is
+underlined is a hyperlink which can be clicked to trigger an
+automatic search for that word.</p>
+<p>Every synset has a hyperlink <b>S:</b> at the start of its
+display line. Clicking that symbol shows you the name of every
+<b>relation</b> that this synset is part of. Every relation name is a hyperlink that opens up a display for that relation. Clicking it another time closes the display again. Clicking another relation name on a line that has an opened relation closes the open relation and opens the clicked relation.</p>
+<p>It is also possible to give two or more words or collocations to be searched at the same time separating them with a comma like this <a href="Mcheer up,clear up">cheer up,clear up</a>, for example. Click the previous link to see what this kind of search looks like and then come back to this page by using the <b>Alt+LeftArrow</b> key combination. As you could see the search result includes the synsets found in the same order than the forms were given in the search field.</p>
+<p>
+There are also word level (lexical) relations recorded in the Wordnet database. Opening this kind of relation displays lines with a hyperlink <b>W:</b> at their beginning. Clicking this link shows more info on the word in question.</p>
+<h3>The Buttons</h3>
+<p>The <b>Search</b> and <b>Help</b> buttons need no more explanation. </p>
+<p>The <b>Show Database Info</b> button shows a collection of Wordnet database statistics.</p>
+<p>The <b>Shutdown the Server</b> button is shown for the first client of the BrowServer program i.e. for the client that is automatically launched when the BrowServer is started but not for the succeeding clients in order to protect the server from accidental shutdowns.
+</p></body>
+</html>
+"""
+
+
+def get_static_welcome_message():
+    """
+    Get the static welcome page.
+    """
+    return """
+<h3>Search Help</h3>
+<ul><li>The display below the line is an example of the output the browser
+shows you when you enter a search word. The search word was <b>green</b>.</li>
+<li>The search result shows for different parts of speech the <b>synsets</b>
+i.e. different meanings for the word.</li>
+<li>All underlined texts are hypertext links. There are two types of links:
+word links and others. Clicking a word link carries out a search for the word
+in the Wordnet database.</li>
+<li>Clicking a link of the other type opens a display section of data attached
+to that link. Clicking that link a second time closes the section again.</li>
+<li>Clicking <u>S:</u> opens a section showing the relations for that synset.</li>
+<li>Clicking on a relation name opens a section that displays the associated
+synsets.</li>
+<li>Type a search word in the <b>Next Word</b> field and start the search by the
+<b>Enter/Return</b> key or click the <b>Search</b> button.</li>
+</ul>
+"""
+
+
+def get_static_index_page(with_shutdown):
+    """
+    Get the static index page.
+    """
+    template = """
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN"  "http://www.w3.org/TR/html4/frameset.dtd">
+<HTML>
+     <!-- Natural Language Toolkit: Wordnet Interface: Graphical Wordnet Browser
+            Copyright (C) 2001-2023 NLTK Project
+            Author: Jussi Salmela <[email protected]>
+            URL: <https://www.nltk.org/>
+            For license information, see LICENSE.TXT -->
+     <HEAD>
+         <TITLE>NLTK Wordnet Browser</TITLE>
+     </HEAD>
+
+<frameset rows="7%%,93%%">
+    <frame src="%s" name="header">
+    <frame src="start_page" name="body">
+</frameset>
+</HTML>
+"""
+    if with_shutdown:
+        upper_link = "upper.html"
+    else:
+        upper_link = "upper_2.html"
+
+    return template % upper_link
+
+
+def get_static_upper_page(with_shutdown):
+    """
+    Return the upper frame page,
+
+    If with_shutdown is True then a 'shutdown' button is also provided
+    to shutdown the server.
+    """
+    template = """
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
+<html>
+    <!-- Natural Language Toolkit: Wordnet Interface: Graphical Wordnet Browser
+        Copyright (C) 2001-2023 NLTK Project
+        Author: Jussi Salmela <[email protected]>
+        URL: <https://www.nltk.org/>
+        For license information, see LICENSE.TXT -->
+    <head>
+                <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <title>Untitled Document</title>
+    </head>
+    <body>
+    <form method="GET" action="search" target="body">
+            Current Word:&nbsp;<input type="text" id="currentWord" size="10" disabled>
+            Next Word:&nbsp;<input type="text" id="nextWord" name="nextWord" size="10">
+            <input name="searchButton" type="submit" value="Search">
+    </form>
+        <a target="body" href="web_help.html">Help</a>
+        %s
+
+</body>
+</html>
+"""
+    if with_shutdown:
+        shutdown_link = '<a href="SHUTDOWN THE SERVER">Shutdown</a>'
+    else:
+        shutdown_link = ""
+
+    return template % shutdown_link
+
+
+def usage():
+    """
+    Display the command line help message.
+    """
+    print(__doc__)
+
+
+def app():
+    # Parse and interpret options.
+    (opts, _) = getopt.getopt(
+        argv[1:], "l:p:sh", ["logfile=", "port=", "server-mode", "help"]
+    )
+    port = 8000
+    server_mode = False
+    help_mode = False
+    logfilename = None
+    for (opt, value) in opts:
+        if (opt == "-l") or (opt == "--logfile"):
+            logfilename = str(value)
+        elif (opt == "-p") or (opt == "--port"):
+            port = int(value)
+        elif (opt == "-s") or (opt == "--server-mode"):
+            server_mode = True
+        elif (opt == "-h") or (opt == "--help"):
+            help_mode = True
+
+    if help_mode:
+        usage()
+    else:
+        wnb(port, not server_mode, logfilename)
+
+
+if __name__ == "__main__":
+    app()
+
+__all__ = ["app"]

env-llmeval/lib/python3.10/site-packages/nltk/classify/api.py

@@ -0,0 +1,195 @@
+# Natural Language Toolkit: Classifier Interface
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]> (minor additions)
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Interfaces for labeling tokens with category labels (or "class labels").
+
+``ClassifierI`` is a standard interface for "single-category
+classification", in which the set of categories is known, the number
+of categories is finite, and each text belongs to exactly one
+category.
+
+``MultiClassifierI`` is a standard interface for "multi-category
+classification", which is like single-category classification except
+that each text belongs to zero or more categories.
+"""
+from nltk.internals import overridden
+
+##//////////////////////////////////////////////////////
+# { Classification Interfaces
+##//////////////////////////////////////////////////////
+
+
+class ClassifierI:
+    """
+    A processing interface for labeling tokens with a single category
+    label (or "class").  Labels are typically strs or
+    ints, but can be any immutable type.  The set of labels
+    that the classifier chooses from must be fixed and finite.
+
+    Subclasses must define:
+      - ``labels()``
+      - either ``classify()`` or ``classify_many()`` (or both)
+
+    Subclasses may define:
+      - either ``prob_classify()`` or ``prob_classify_many()`` (or both)
+    """
+
+    def labels(self):
+        """
+        :return: the list of category labels used by this classifier.
+        :rtype: list of (immutable)
+        """
+        raise NotImplementedError()
+
+    def classify(self, featureset):
+        """
+        :return: the most appropriate label for the given featureset.
+        :rtype: label
+        """
+        if overridden(self.classify_many):
+            return self.classify_many([featureset])[0]
+        else:
+            raise NotImplementedError()
+
+    def prob_classify(self, featureset):
+        """
+        :return: a probability distribution over labels for the given
+            featureset.
+        :rtype: ProbDistI
+        """
+        if overridden(self.prob_classify_many):
+            return self.prob_classify_many([featureset])[0]
+        else:
+            raise NotImplementedError()
+
+    def classify_many(self, featuresets):
+        """
+        Apply ``self.classify()`` to each element of ``featuresets``.  I.e.:
+
+            return [self.classify(fs) for fs in featuresets]
+
+        :rtype: list(label)
+        """
+        return [self.classify(fs) for fs in featuresets]
+
+    def prob_classify_many(self, featuresets):
+        """
+        Apply ``self.prob_classify()`` to each element of ``featuresets``.  I.e.:
+
+            return [self.prob_classify(fs) for fs in featuresets]
+
+        :rtype: list(ProbDistI)
+        """
+        return [self.prob_classify(fs) for fs in featuresets]
+
+
+class MultiClassifierI:
+    """
+    A processing interface for labeling tokens with zero or more
+    category labels (or "labels").  Labels are typically strs
+    or ints, but can be any immutable type.  The set of labels
+    that the multi-classifier chooses from must be fixed and finite.
+
+    Subclasses must define:
+      - ``labels()``
+      - either ``classify()`` or ``classify_many()`` (or both)
+
+    Subclasses may define:
+      - either ``prob_classify()`` or ``prob_classify_many()`` (or both)
+    """
+
+    def labels(self):
+        """
+        :return: the list of category labels used by this classifier.
+        :rtype: list of (immutable)
+        """
+        raise NotImplementedError()
+
+    def classify(self, featureset):
+        """
+        :return: the most appropriate set of labels for the given featureset.
+        :rtype: set(label)
+        """
+        if overridden(self.classify_many):
+            return self.classify_many([featureset])[0]
+        else:
+            raise NotImplementedError()
+
+    def prob_classify(self, featureset):
+        """
+        :return: a probability distribution over sets of labels for the
+            given featureset.
+        :rtype: ProbDistI
+        """
+        if overridden(self.prob_classify_many):
+            return self.prob_classify_many([featureset])[0]
+        else:
+            raise NotImplementedError()
+
+    def classify_many(self, featuresets):
+        """
+        Apply ``self.classify()`` to each element of ``featuresets``.  I.e.:
+
+            return [self.classify(fs) for fs in featuresets]
+
+        :rtype: list(set(label))
+        """
+        return [self.classify(fs) for fs in featuresets]
+
+    def prob_classify_many(self, featuresets):
+        """
+        Apply ``self.prob_classify()`` to each element of ``featuresets``.  I.e.:
+
+            return [self.prob_classify(fs) for fs in featuresets]
+
+        :rtype: list(ProbDistI)
+        """
+        return [self.prob_classify(fs) for fs in featuresets]
+
+
+# # [XX] IN PROGRESS:
+# class SequenceClassifierI:
+#     """
+#     A processing interface for labeling sequences of tokens with a
+#     single category label (or "class").  Labels are typically
+#     strs or ints, but can be any immutable type.  The set
+#     of labels that the classifier chooses from must be fixed and
+#     finite.
+#     """
+#     def labels(self):
+#         """
+#         :return: the list of category labels used by this classifier.
+#         :rtype: list of (immutable)
+#         """
+#         raise NotImplementedError()
+
+#     def prob_classify(self, featureset):
+#         """
+#         Return a probability distribution over labels for the given
+#         featureset.
+
+#         If ``featureset`` is a list of featuresets, then return a
+#         corresponding list containing the probability distribution
+#         over labels for each of the given featuresets, where the
+#         *i*\ th element of this list is the most appropriate label for
+#         the *i*\ th element of ``featuresets``.
+#         """
+#         raise NotImplementedError()
+
+#     def classify(self, featureset):
+#         """
+#         Return the most appropriate label for the given featureset.
+
+#         If ``featureset`` is a list of featuresets, then return a
+#         corresponding list containing the most appropriate label for
+#         each of the given featuresets, where the *i*\ th element of
+#         this list is the most appropriate label for the *i*\ th element
+#         of ``featuresets``.
+#         """
+#         raise NotImplementedError()

env-llmeval/lib/python3.10/site-packages/nltk/classify/decisiontree.py

@@ -0,0 +1,349 @@
+# Natural Language Toolkit: Decision Tree Classifiers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A classifier model that decides which label to assign to a token on
+the basis of a tree structure, where branches correspond to conditions
+on feature values, and leaves correspond to label assignments.
+"""
+
+from collections import defaultdict
+
+from nltk.classify.api import ClassifierI
+from nltk.probability import FreqDist, MLEProbDist, entropy
+
+
+class DecisionTreeClassifier(ClassifierI):
+    def __init__(self, label, feature_name=None, decisions=None, default=None):
+        """
+        :param label: The most likely label for tokens that reach
+            this node in the decision tree.  If this decision tree
+            has no children, then this label will be assigned to
+            any token that reaches this decision tree.
+        :param feature_name: The name of the feature that this
+            decision tree selects for.
+        :param decisions: A dictionary mapping from feature values
+            for the feature identified by ``feature_name`` to
+            child decision trees.
+        :param default: The child that will be used if the value of
+            feature ``feature_name`` does not match any of the keys in
+            ``decisions``.  This is used when constructing binary
+            decision trees.
+        """
+        self._label = label
+        self._fname = feature_name
+        self._decisions = decisions
+        self._default = default
+
+    def labels(self):
+        labels = [self._label]
+        if self._decisions is not None:
+            for dt in self._decisions.values():
+                labels.extend(dt.labels())
+        if self._default is not None:
+            labels.extend(self._default.labels())
+        return list(set(labels))
+
+    def classify(self, featureset):
+        # Decision leaf:
+        if self._fname is None:
+            return self._label
+
+        # Decision tree:
+        fval = featureset.get(self._fname)
+        if fval in self._decisions:
+            return self._decisions[fval].classify(featureset)
+        elif self._default is not None:
+            return self._default.classify(featureset)
+        else:
+            return self._label
+
+    def error(self, labeled_featuresets):
+        errors = 0
+        for featureset, label in labeled_featuresets:
+            if self.classify(featureset) != label:
+                errors += 1
+        return errors / len(labeled_featuresets)
+
+    def pretty_format(self, width=70, prefix="", depth=4):
+        """
+        Return a string containing a pretty-printed version of this
+        decision tree.  Each line in this string corresponds to a
+        single decision tree node or leaf, and indentation is used to
+        display the structure of the decision tree.
+        """
+        # [xx] display default!!
+        if self._fname is None:
+            n = width - len(prefix) - 15
+            return "{}{} {}\n".format(prefix, "." * n, self._label)
+        s = ""
+        for i, (fval, result) in enumerate(
+            sorted(
+                self._decisions.items(),
+                key=lambda item: (item[0] in [None, False, True], str(item[0]).lower()),
+            )
+        ):
+            hdr = f"{prefix}{self._fname}={fval}? "
+            n = width - 15 - len(hdr)
+            s += "{}{} {}\n".format(hdr, "." * (n), result._label)
+            if result._fname is not None and depth > 1:
+                s += result.pretty_format(width, prefix + "  ", depth - 1)
+        if self._default is not None:
+            n = width - len(prefix) - 21
+            s += "{}else: {} {}\n".format(prefix, "." * n, self._default._label)
+            if self._default._fname is not None and depth > 1:
+                s += self._default.pretty_format(width, prefix + "  ", depth - 1)
+        return s
+
+    def pseudocode(self, prefix="", depth=4):
+        """
+        Return a string representation of this decision tree that
+        expresses the decisions it makes as a nested set of pseudocode
+        if statements.
+        """
+        if self._fname is None:
+            return f"{prefix}return {self._label!r}\n"
+        s = ""
+        for (fval, result) in sorted(
+            self._decisions.items(),
+            key=lambda item: (item[0] in [None, False, True], str(item[0]).lower()),
+        ):
+            s += f"{prefix}if {self._fname} == {fval!r}: "
+            if result._fname is not None and depth > 1:
+                s += "\n" + result.pseudocode(prefix + "  ", depth - 1)
+            else:
+                s += f"return {result._label!r}\n"
+        if self._default is not None:
+            if len(self._decisions) == 1:
+                s += "{}if {} != {!r}: ".format(
+                    prefix, self._fname, list(self._decisions.keys())[0]
+                )
+            else:
+                s += f"{prefix}else: "
+            if self._default._fname is not None and depth > 1:
+                s += "\n" + self._default.pseudocode(prefix + "  ", depth - 1)
+            else:
+                s += f"return {self._default._label!r}\n"
+        return s
+
+    def __str__(self):
+        return self.pretty_format()
+
+    @staticmethod
+    def train(
+        labeled_featuresets,
+        entropy_cutoff=0.05,
+        depth_cutoff=100,
+        support_cutoff=10,
+        binary=False,
+        feature_values=None,
+        verbose=False,
+    ):
+        """
+        :param binary: If true, then treat all feature/value pairs as
+            individual binary features, rather than using a single n-way
+            branch for each feature.
+        """
+        # Collect a list of all feature names.
+        feature_names = set()
+        for featureset, label in labeled_featuresets:
+            for fname in featureset:
+                feature_names.add(fname)
+
+        # Collect a list of the values each feature can take.
+        if feature_values is None and binary:
+            feature_values = defaultdict(set)
+            for featureset, label in labeled_featuresets:
+                for fname, fval in featureset.items():
+                    feature_values[fname].add(fval)
+
+        # Start with a stump.
+        if not binary:
+            tree = DecisionTreeClassifier.best_stump(
+                feature_names, labeled_featuresets, verbose
+            )
+        else:
+            tree = DecisionTreeClassifier.best_binary_stump(
+                feature_names, labeled_featuresets, feature_values, verbose
+            )
+
+        # Refine the stump.
+        tree.refine(
+            labeled_featuresets,
+            entropy_cutoff,
+            depth_cutoff - 1,
+            support_cutoff,
+            binary,
+            feature_values,
+            verbose,
+        )
+
+        # Return it
+        return tree
+
+    @staticmethod
+    def leaf(labeled_featuresets):
+        label = FreqDist(label for (featureset, label) in labeled_featuresets).max()
+        return DecisionTreeClassifier(label)
+
+    @staticmethod
+    def stump(feature_name, labeled_featuresets):
+        label = FreqDist(label for (featureset, label) in labeled_featuresets).max()
+
+        # Find the best label for each value.
+        freqs = defaultdict(FreqDist)  # freq(label|value)
+        for featureset, label in labeled_featuresets:
+            feature_value = featureset.get(feature_name)
+            freqs[feature_value][label] += 1
+
+        decisions = {val: DecisionTreeClassifier(freqs[val].max()) for val in freqs}
+        return DecisionTreeClassifier(label, feature_name, decisions)
+
+    def refine(
+        self,
+        labeled_featuresets,
+        entropy_cutoff,
+        depth_cutoff,
+        support_cutoff,
+        binary=False,
+        feature_values=None,
+        verbose=False,
+    ):
+        if len(labeled_featuresets) <= support_cutoff:
+            return
+        if self._fname is None:
+            return
+        if depth_cutoff <= 0:
+            return
+        for fval in self._decisions:
+            fval_featuresets = [
+                (featureset, label)
+                for (featureset, label) in labeled_featuresets
+                if featureset.get(self._fname) == fval
+            ]
+
+            label_freqs = FreqDist(label for (featureset, label) in fval_featuresets)
+            if entropy(MLEProbDist(label_freqs)) > entropy_cutoff:
+                self._decisions[fval] = DecisionTreeClassifier.train(
+                    fval_featuresets,
+                    entropy_cutoff,
+                    depth_cutoff,
+                    support_cutoff,
+                    binary,
+                    feature_values,
+                    verbose,
+                )
+        if self._default is not None:
+            default_featuresets = [
+                (featureset, label)
+                for (featureset, label) in labeled_featuresets
+                if featureset.get(self._fname) not in self._decisions
+            ]
+            label_freqs = FreqDist(label for (featureset, label) in default_featuresets)
+            if entropy(MLEProbDist(label_freqs)) > entropy_cutoff:
+                self._default = DecisionTreeClassifier.train(
+                    default_featuresets,
+                    entropy_cutoff,
+                    depth_cutoff,
+                    support_cutoff,
+                    binary,
+                    feature_values,
+                    verbose,
+                )
+
+    @staticmethod
+    def best_stump(feature_names, labeled_featuresets, verbose=False):
+        best_stump = DecisionTreeClassifier.leaf(labeled_featuresets)
+        best_error = best_stump.error(labeled_featuresets)
+        for fname in feature_names:
+            stump = DecisionTreeClassifier.stump(fname, labeled_featuresets)
+            stump_error = stump.error(labeled_featuresets)
+            if stump_error < best_error:
+                best_error = stump_error
+                best_stump = stump
+        if verbose:
+            print(
+                "best stump for {:6d} toks uses {:20} err={:6.4f}".format(
+                    len(labeled_featuresets), best_stump._fname, best_error
+                )
+            )
+        return best_stump
+
+    @staticmethod
+    def binary_stump(feature_name, feature_value, labeled_featuresets):
+        label = FreqDist(label for (featureset, label) in labeled_featuresets).max()
+
+        # Find the best label for each value.
+        pos_fdist = FreqDist()
+        neg_fdist = FreqDist()
+        for featureset, label in labeled_featuresets:
+            if featureset.get(feature_name) == feature_value:
+                pos_fdist[label] += 1
+            else:
+                neg_fdist[label] += 1
+
+        decisions = {}
+        default = label
+        # But hopefully we have observations!
+        if pos_fdist.N() > 0:
+            decisions = {feature_value: DecisionTreeClassifier(pos_fdist.max())}
+        if neg_fdist.N() > 0:
+            default = DecisionTreeClassifier(neg_fdist.max())
+
+        return DecisionTreeClassifier(label, feature_name, decisions, default)
+
+    @staticmethod
+    def best_binary_stump(
+        feature_names, labeled_featuresets, feature_values, verbose=False
+    ):
+        best_stump = DecisionTreeClassifier.leaf(labeled_featuresets)
+        best_error = best_stump.error(labeled_featuresets)
+        for fname in feature_names:
+            for fval in feature_values[fname]:
+                stump = DecisionTreeClassifier.binary_stump(
+                    fname, fval, labeled_featuresets
+                )
+                stump_error = stump.error(labeled_featuresets)
+                if stump_error < best_error:
+                    best_error = stump_error
+                    best_stump = stump
+        if verbose:
+            if best_stump._decisions:
+                descr = "{}={}".format(
+                    best_stump._fname, list(best_stump._decisions.keys())[0]
+                )
+            else:
+                descr = "(default)"
+            print(
+                "best stump for {:6d} toks uses {:20} err={:6.4f}".format(
+                    len(labeled_featuresets), descr, best_error
+                )
+            )
+        return best_stump
+
+
+##//////////////////////////////////////////////////////
+##  Demo
+##//////////////////////////////////////////////////////
+
+
+def f(x):
+    return DecisionTreeClassifier.train(x, binary=True, verbose=True)
+
+
+def demo():
+    from nltk.classify.util import binary_names_demo_features, names_demo
+
+    classifier = names_demo(
+        f, binary_names_demo_features  # DecisionTreeClassifier.train,
+    )
+    print(classifier.pretty_format(depth=7))
+    print(classifier.pseudocode(depth=7))
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/classify/maxent.py

@@ -0,0 +1,1569 @@
+# Natural Language Toolkit: Maximum Entropy Classifiers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Dmitry Chichkov <[email protected]> (TypedMaxentFeatureEncoding)
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A classifier model based on maximum entropy modeling framework.  This
+framework considers all of the probability distributions that are
+empirically consistent with the training data; and chooses the
+distribution with the highest entropy.  A probability distribution is
+"empirically consistent" with a set of training data if its estimated
+frequency with which a class and a feature vector value co-occur is
+equal to the actual frequency in the data.
+
+Terminology: 'feature'
+======================
+The term *feature* is usually used to refer to some property of an
+unlabeled token.  For example, when performing word sense
+disambiguation, we might define a ``'prevword'`` feature whose value is
+the word preceding the target word.  However, in the context of
+maxent modeling, the term *feature* is typically used to refer to a
+property of a "labeled" token.  In order to prevent confusion, we
+will introduce two distinct terms to disambiguate these two different
+concepts:
+
+  - An "input-feature" is a property of an unlabeled token.
+  - A "joint-feature" is a property of a labeled token.
+
+In the rest of the ``nltk.classify`` module, the term "features" is
+used to refer to what we will call "input-features" in this module.
+
+In literature that describes and discusses maximum entropy models,
+input-features are typically called "contexts", and joint-features
+are simply referred to as "features".
+
+Converting Input-Features to Joint-Features
+-------------------------------------------
+In maximum entropy models, joint-features are required to have numeric
+values.  Typically, each input-feature ``input_feat`` is mapped to a
+set of joint-features of the form:
+
+|   joint_feat(token, label) = { 1 if input_feat(token) == feat_val
+|                              {      and label == some_label
+|                              {
+|                              { 0 otherwise
+
+For all values of ``feat_val`` and ``some_label``.  This mapping is
+performed by classes that implement the ``MaxentFeatureEncodingI``
+interface.
+"""
+try:
+    import numpy
+except ImportError:
+    pass
+
+import os
+import tempfile
+from collections import defaultdict
+
+from nltk.classify.api import ClassifierI
+from nltk.classify.megam import call_megam, parse_megam_weights, write_megam_file
+from nltk.classify.tadm import call_tadm, parse_tadm_weights, write_tadm_file
+from nltk.classify.util import CutoffChecker, accuracy, log_likelihood
+from nltk.data import gzip_open_unicode
+from nltk.probability import DictionaryProbDist
+from nltk.util import OrderedDict
+
+__docformat__ = "epytext en"
+
+######################################################################
+# { Classifier Model
+######################################################################
+
+
+class MaxentClassifier(ClassifierI):
+    """
+    A maximum entropy classifier (also known as a "conditional
+    exponential classifier").  This classifier is parameterized by a
+    set of "weights", which are used to combine the joint-features
+    that are generated from a featureset by an "encoding".  In
+    particular, the encoding maps each ``(featureset, label)`` pair to
+    a vector.  The probability of each label is then computed using
+    the following equation::
+
+                                dotprod(weights, encode(fs,label))
+      prob(fs|label) = ---------------------------------------------------
+                       sum(dotprod(weights, encode(fs,l)) for l in labels)
+
+    Where ``dotprod`` is the dot product::
+
+      dotprod(a,b) = sum(x*y for (x,y) in zip(a,b))
+    """
+
+    def __init__(self, encoding, weights, logarithmic=True):
+        """
+        Construct a new maxent classifier model.  Typically, new
+        classifier models are created using the ``train()`` method.
+
+        :type encoding: MaxentFeatureEncodingI
+        :param encoding: An encoding that is used to convert the
+            featuresets that are given to the ``classify`` method into
+            joint-feature vectors, which are used by the maxent
+            classifier model.
+
+        :type weights: list of float
+        :param weights:  The feature weight vector for this classifier.
+
+        :type logarithmic: bool
+        :param logarithmic: If false, then use non-logarithmic weights.
+        """
+        self._encoding = encoding
+        self._weights = weights
+        self._logarithmic = logarithmic
+        # self._logarithmic = False
+        assert encoding.length() == len(weights)
+
+    def labels(self):
+        return self._encoding.labels()
+
+    def set_weights(self, new_weights):
+        """
+        Set the feature weight vector for this classifier.
+        :param new_weights: The new feature weight vector.
+        :type new_weights: list of float
+        """
+        self._weights = new_weights
+        assert self._encoding.length() == len(new_weights)
+
+    def weights(self):
+        """
+        :return: The feature weight vector for this classifier.
+        :rtype: list of float
+        """
+        return self._weights
+
+    def classify(self, featureset):
+        return self.prob_classify(featureset).max()
+
+    def prob_classify(self, featureset):
+        prob_dict = {}
+        for label in self._encoding.labels():
+            feature_vector = self._encoding.encode(featureset, label)
+
+            if self._logarithmic:
+                total = 0.0
+                for (f_id, f_val) in feature_vector:
+                    total += self._weights[f_id] * f_val
+                prob_dict[label] = total
+
+            else:
+                prod = 1.0
+                for (f_id, f_val) in feature_vector:
+                    prod *= self._weights[f_id] ** f_val
+                prob_dict[label] = prod
+
+        # Normalize the dictionary to give a probability distribution
+        return DictionaryProbDist(prob_dict, log=self._logarithmic, normalize=True)
+
+    def explain(self, featureset, columns=4):
+        """
+        Print a table showing the effect of each of the features in
+        the given feature set, and how they combine to determine the
+        probabilities of each label for that featureset.
+        """
+        descr_width = 50
+        TEMPLATE = "  %-" + str(descr_width - 2) + "s%s%8.3f"
+
+        pdist = self.prob_classify(featureset)
+        labels = sorted(pdist.samples(), key=pdist.prob, reverse=True)
+        labels = labels[:columns]
+        print(
+            "  Feature".ljust(descr_width)
+            + "".join("%8s" % (("%s" % l)[:7]) for l in labels)
+        )
+        print("  " + "-" * (descr_width - 2 + 8 * len(labels)))
+        sums = defaultdict(int)
+        for i, label in enumerate(labels):
+            feature_vector = self._encoding.encode(featureset, label)
+            feature_vector.sort(
+                key=lambda fid__: abs(self._weights[fid__[0]]), reverse=True
+            )
+            for (f_id, f_val) in feature_vector:
+                if self._logarithmic:
+                    score = self._weights[f_id] * f_val
+                else:
+                    score = self._weights[f_id] ** f_val
+                descr = self._encoding.describe(f_id)
+                descr = descr.split(" and label is ")[0]  # hack
+                descr += " (%s)" % f_val  # hack
+                if len(descr) > 47:
+                    descr = descr[:44] + "..."
+                print(TEMPLATE % (descr, i * 8 * " ", score))
+                sums[label] += score
+        print("  " + "-" * (descr_width - 1 + 8 * len(labels)))
+        print(
+            "  TOTAL:".ljust(descr_width) + "".join("%8.3f" % sums[l] for l in labels)
+        )
+        print(
+            "  PROBS:".ljust(descr_width)
+            + "".join("%8.3f" % pdist.prob(l) for l in labels)
+        )
+
+    def most_informative_features(self, n=10):
+        """
+        Generates the ranked list of informative features from most to least.
+        """
+        if hasattr(self, "_most_informative_features"):
+            return self._most_informative_features[:n]
+        else:
+            self._most_informative_features = sorted(
+                list(range(len(self._weights))),
+                key=lambda fid: abs(self._weights[fid]),
+                reverse=True,
+            )
+            return self._most_informative_features[:n]
+
+    def show_most_informative_features(self, n=10, show="all"):
+        """
+        :param show: all, neg, or pos (for negative-only or positive-only)
+        :type show: str
+        :param n: The no. of top features
+        :type n: int
+        """
+        # Use None the full list of ranked features.
+        fids = self.most_informative_features(None)
+        if show == "pos":
+            fids = [fid for fid in fids if self._weights[fid] > 0]
+        elif show == "neg":
+            fids = [fid for fid in fids if self._weights[fid] < 0]
+        for fid in fids[:n]:
+            print(f"{self._weights[fid]:8.3f} {self._encoding.describe(fid)}")
+
+    def __repr__(self):
+        return "<ConditionalExponentialClassifier: %d labels, %d features>" % (
+            len(self._encoding.labels()),
+            self._encoding.length(),
+        )
+
+    #: A list of the algorithm names that are accepted for the
+    #: ``train()`` method's ``algorithm`` parameter.
+    ALGORITHMS = ["GIS", "IIS", "MEGAM", "TADM"]
+
+    @classmethod
+    def train(
+        cls,
+        train_toks,
+        algorithm=None,
+        trace=3,
+        encoding=None,
+        labels=None,
+        gaussian_prior_sigma=0,
+        **cutoffs,
+    ):
+        """
+        Train a new maxent classifier based on the given corpus of
+        training samples.  This classifier will have its weights
+        chosen to maximize entropy while remaining empirically
+        consistent with the training corpus.
+
+        :rtype: MaxentClassifier
+        :return: The new maxent classifier
+
+        :type train_toks: list
+        :param train_toks: Training data, represented as a list of
+            pairs, the first member of which is a featureset,
+            and the second of which is a classification label.
+
+        :type algorithm: str
+        :param algorithm: A case-insensitive string, specifying which
+            algorithm should be used to train the classifier.  The
+            following algorithms are currently available.
+
+            - Iterative Scaling Methods: Generalized Iterative Scaling (``'GIS'``),
+              Improved Iterative Scaling (``'IIS'``)
+            - External Libraries (requiring megam):
+              LM-BFGS algorithm, with training performed by Megam (``'megam'``)
+
+            The default algorithm is ``'IIS'``.
+
+        :type trace: int
+        :param trace: The level of diagnostic tracing output to produce.
+            Higher values produce more verbose output.
+        :type encoding: MaxentFeatureEncodingI
+        :param encoding: A feature encoding, used to convert featuresets
+            into feature vectors.  If none is specified, then a
+            ``BinaryMaxentFeatureEncoding`` will be built based on the
+            features that are attested in the training corpus.
+        :type labels: list(str)
+        :param labels: The set of possible labels.  If none is given, then
+            the set of all labels attested in the training data will be
+            used instead.
+        :param gaussian_prior_sigma: The sigma value for a gaussian
+            prior on model weights.  Currently, this is supported by
+            ``megam``. For other algorithms, its value is ignored.
+        :param cutoffs: Arguments specifying various conditions under
+            which the training should be halted.  (Some of the cutoff
+            conditions are not supported by some algorithms.)
+
+            - ``max_iter=v``: Terminate after ``v`` iterations.
+            - ``min_ll=v``: Terminate after the negative average
+              log-likelihood drops under ``v``.
+            - ``min_lldelta=v``: Terminate if a single iteration improves
+              log likelihood by less than ``v``.
+        """
+        if algorithm is None:
+            algorithm = "iis"
+        for key in cutoffs:
+            if key not in (
+                "max_iter",
+                "min_ll",
+                "min_lldelta",
+                "max_acc",
+                "min_accdelta",
+                "count_cutoff",
+                "norm",
+                "explicit",
+                "bernoulli",
+            ):
+                raise TypeError("Unexpected keyword arg %r" % key)
+        algorithm = algorithm.lower()
+        if algorithm == "iis":
+            return train_maxent_classifier_with_iis(
+                train_toks, trace, encoding, labels, **cutoffs
+            )
+        elif algorithm == "gis":
+            return train_maxent_classifier_with_gis(
+                train_toks, trace, encoding, labels, **cutoffs
+            )
+        elif algorithm == "megam":
+            return train_maxent_classifier_with_megam(
+                train_toks, trace, encoding, labels, gaussian_prior_sigma, **cutoffs
+            )
+        elif algorithm == "tadm":
+            kwargs = cutoffs
+            kwargs["trace"] = trace
+            kwargs["encoding"] = encoding
+            kwargs["labels"] = labels
+            kwargs["gaussian_prior_sigma"] = gaussian_prior_sigma
+            return TadmMaxentClassifier.train(train_toks, **kwargs)
+        else:
+            raise ValueError("Unknown algorithm %s" % algorithm)
+
+
+#: Alias for MaxentClassifier.
+ConditionalExponentialClassifier = MaxentClassifier
+
+
+######################################################################
+# { Feature Encodings
+######################################################################
+
+
+class MaxentFeatureEncodingI:
+    """
+    A mapping that converts a set of input-feature values to a vector
+    of joint-feature values, given a label.  This conversion is
+    necessary to translate featuresets into a format that can be used
+    by maximum entropy models.
+
+    The set of joint-features used by a given encoding is fixed, and
+    each index in the generated joint-feature vectors corresponds to a
+    single joint-feature.  The length of the generated joint-feature
+    vectors is therefore constant (for a given encoding).
+
+    Because the joint-feature vectors generated by
+    ``MaxentFeatureEncodingI`` are typically very sparse, they are
+    represented as a list of ``(index, value)`` tuples, specifying the
+    value of each non-zero joint-feature.
+
+    Feature encodings are generally created using the ``train()``
+    method, which generates an appropriate encoding based on the
+    input-feature values and labels that are present in a given
+    corpus.
+    """
+
+    def encode(self, featureset, label):
+        """
+        Given a (featureset, label) pair, return the corresponding
+        vector of joint-feature values.  This vector is represented as
+        a list of ``(index, value)`` tuples, specifying the value of
+        each non-zero joint-feature.
+
+        :type featureset: dict
+        :rtype: list(tuple(int, int))
+        """
+        raise NotImplementedError()
+
+    def length(self):
+        """
+        :return: The size of the fixed-length joint-feature vectors
+            that are generated by this encoding.
+        :rtype: int
+        """
+        raise NotImplementedError()
+
+    def labels(self):
+        """
+        :return: A list of the \"known labels\" -- i.e., all labels
+            ``l`` such that ``self.encode(fs,l)`` can be a nonzero
+            joint-feature vector for some value of ``fs``.
+        :rtype: list
+        """
+        raise NotImplementedError()
+
+    def describe(self, fid):
+        """
+        :return: A string describing the value of the joint-feature
+            whose index in the generated feature vectors is ``fid``.
+        :rtype: str
+        """
+        raise NotImplementedError()
+
+    def train(cls, train_toks):
+        """
+        Construct and return new feature encoding, based on a given
+        training corpus ``train_toks``.
+
+        :type train_toks: list(tuple(dict, str))
+        :param train_toks: Training data, represented as a list of
+            pairs, the first member of which is a feature dictionary,
+            and the second of which is a classification label.
+        """
+        raise NotImplementedError()
+
+
+class FunctionBackedMaxentFeatureEncoding(MaxentFeatureEncodingI):
+    """
+    A feature encoding that calls a user-supplied function to map a
+    given featureset/label pair to a sparse joint-feature vector.
+    """
+
+    def __init__(self, func, length, labels):
+        """
+        Construct a new feature encoding based on the given function.
+
+        :type func: (callable)
+        :param func: A function that takes two arguments, a featureset
+             and a label, and returns the sparse joint feature vector
+             that encodes them::
+
+                 func(featureset, label) -> feature_vector
+
+             This sparse joint feature vector (``feature_vector``) is a
+             list of ``(index,value)`` tuples.
+
+        :type length: int
+        :param length: The size of the fixed-length joint-feature
+            vectors that are generated by this encoding.
+
+        :type labels: list
+        :param labels: A list of the \"known labels\" for this
+            encoding -- i.e., all labels ``l`` such that
+            ``self.encode(fs,l)`` can be a nonzero joint-feature vector
+            for some value of ``fs``.
+        """
+        self._length = length
+        self._func = func
+        self._labels = labels
+
+    def encode(self, featureset, label):
+        return self._func(featureset, label)
+
+    def length(self):
+        return self._length
+
+    def labels(self):
+        return self._labels
+
+    def describe(self, fid):
+        return "no description available"
+
+
+class BinaryMaxentFeatureEncoding(MaxentFeatureEncodingI):
+    """
+    A feature encoding that generates vectors containing a binary
+    joint-features of the form:
+
+    |  joint_feat(fs, l) = { 1 if (fs[fname] == fval) and (l == label)
+    |                      {
+    |                      { 0 otherwise
+
+    Where ``fname`` is the name of an input-feature, ``fval`` is a value
+    for that input-feature, and ``label`` is a label.
+
+    Typically, these features are constructed based on a training
+    corpus, using the ``train()`` method.  This method will create one
+    feature for each combination of ``fname``, ``fval``, and ``label``
+    that occurs at least once in the training corpus.
+
+    The ``unseen_features`` parameter can be used to add "unseen-value
+    features", which are used whenever an input feature has a value
+    that was not encountered in the training corpus.  These features
+    have the form:
+
+    |  joint_feat(fs, l) = { 1 if is_unseen(fname, fs[fname])
+    |                      {      and l == label
+    |                      {
+    |                      { 0 otherwise
+
+    Where ``is_unseen(fname, fval)`` is true if the encoding does not
+    contain any joint features that are true when ``fs[fname]==fval``.
+
+    The ``alwayson_features`` parameter can be used to add "always-on
+    features", which have the form::
+
+    |  joint_feat(fs, l) = { 1 if (l == label)
+    |                      {
+    |                      { 0 otherwise
+
+    These always-on features allow the maxent model to directly model
+    the prior probabilities of each label.
+    """
+
+    def __init__(self, labels, mapping, unseen_features=False, alwayson_features=False):
+        """
+        :param labels: A list of the \"known labels\" for this encoding.
+
+        :param mapping: A dictionary mapping from ``(fname,fval,label)``
+            tuples to corresponding joint-feature indexes.  These
+            indexes must be the set of integers from 0...len(mapping).
+            If ``mapping[fname,fval,label]=id``, then
+            ``self.encode(..., fname:fval, ..., label)[id]`` is 1;
+            otherwise, it is 0.
+
+        :param unseen_features: If true, then include unseen value
+           features in the generated joint-feature vectors.
+
+        :param alwayson_features: If true, then include always-on
+           features in the generated joint-feature vectors.
+        """
+        if set(mapping.values()) != set(range(len(mapping))):
+            raise ValueError(
+                "Mapping values must be exactly the "
+                "set of integers from 0...len(mapping)"
+            )
+
+        self._labels = list(labels)
+        """A list of attested labels."""
+
+        self._mapping = mapping
+        """dict mapping from (fname,fval,label) -> fid"""
+
+        self._length = len(mapping)
+        """The length of generated joint feature vectors."""
+
+        self._alwayson = None
+        """dict mapping from label -> fid"""
+
+        self._unseen = None
+        """dict mapping from fname -> fid"""
+
+        if alwayson_features:
+            self._alwayson = {
+                label: i + self._length for (i, label) in enumerate(labels)
+            }
+            self._length += len(self._alwayson)
+
+        if unseen_features:
+            fnames = {fname for (fname, fval, label) in mapping}
+            self._unseen = {fname: i + self._length for (i, fname) in enumerate(fnames)}
+            self._length += len(fnames)
+
+    def encode(self, featureset, label):
+        # Inherit docs.
+        encoding = []
+
+        # Convert input-features to joint-features:
+        for fname, fval in featureset.items():
+            # Known feature name & value:
+            if (fname, fval, label) in self._mapping:
+                encoding.append((self._mapping[fname, fval, label], 1))
+
+            # Otherwise, we might want to fire an "unseen-value feature".
+            elif self._unseen:
+                # Have we seen this fname/fval combination with any label?
+                for label2 in self._labels:
+                    if (fname, fval, label2) in self._mapping:
+                        break  # we've seen this fname/fval combo
+                # We haven't -- fire the unseen-value feature
+                else:
+                    if fname in self._unseen:
+                        encoding.append((self._unseen[fname], 1))
+
+        # Add always-on features:
+        if self._alwayson and label in self._alwayson:
+            encoding.append((self._alwayson[label], 1))
+
+        return encoding
+
+    def describe(self, f_id):
+        # Inherit docs.
+        if not isinstance(f_id, int):
+            raise TypeError("describe() expected an int")
+        try:
+            self._inv_mapping
+        except AttributeError:
+            self._inv_mapping = [-1] * len(self._mapping)
+            for (info, i) in self._mapping.items():
+                self._inv_mapping[i] = info
+
+        if f_id < len(self._mapping):
+            (fname, fval, label) = self._inv_mapping[f_id]
+            return f"{fname}=={fval!r} and label is {label!r}"
+        elif self._alwayson and f_id in self._alwayson.values():
+            for (label, f_id2) in self._alwayson.items():
+                if f_id == f_id2:
+                    return "label is %r" % label
+        elif self._unseen and f_id in self._unseen.values():
+            for (fname, f_id2) in self._unseen.items():
+                if f_id == f_id2:
+                    return "%s is unseen" % fname
+        else:
+            raise ValueError("Bad feature id")
+
+    def labels(self):
+        # Inherit docs.
+        return self._labels
+
+    def length(self):
+        # Inherit docs.
+        return self._length
+
+    @classmethod
+    def train(cls, train_toks, count_cutoff=0, labels=None, **options):
+        """
+        Construct and return new feature encoding, based on a given
+        training corpus ``train_toks``.  See the class description
+        ``BinaryMaxentFeatureEncoding`` for a description of the
+        joint-features that will be included in this encoding.
+
+        :type train_toks: list(tuple(dict, str))
+        :param train_toks: Training data, represented as a list of
+            pairs, the first member of which is a feature dictionary,
+            and the second of which is a classification label.
+
+        :type count_cutoff: int
+        :param count_cutoff: A cutoff value that is used to discard
+            rare joint-features.  If a joint-feature's value is 1
+            fewer than ``count_cutoff`` times in the training corpus,
+            then that joint-feature is not included in the generated
+            encoding.
+
+        :type labels: list
+        :param labels: A list of labels that should be used by the
+            classifier.  If not specified, then the set of labels
+            attested in ``train_toks`` will be used.
+
+        :param options: Extra parameters for the constructor, such as
+            ``unseen_features`` and ``alwayson_features``.
+        """
+        mapping = {}  # maps (fname, fval, label) -> fid
+        seen_labels = set()  # The set of labels we've encountered
+        count = defaultdict(int)  # maps (fname, fval) -> count
+
+        for (tok, label) in train_toks:
+            if labels and label not in labels:
+                raise ValueError("Unexpected label %s" % label)
+            seen_labels.add(label)
+
+            # Record each of the features.
+            for (fname, fval) in tok.items():
+
+                # If a count cutoff is given, then only add a joint
+                # feature once the corresponding (fname, fval, label)
+                # tuple exceeds that cutoff.
+                count[fname, fval] += 1
+                if count[fname, fval] >= count_cutoff:
+                    if (fname, fval, label) not in mapping:
+                        mapping[fname, fval, label] = len(mapping)
+
+        if labels is None:
+            labels = seen_labels
+        return cls(labels, mapping, **options)
+
+
+class GISEncoding(BinaryMaxentFeatureEncoding):
+    """
+    A binary feature encoding which adds one new joint-feature to the
+    joint-features defined by ``BinaryMaxentFeatureEncoding``: a
+    correction feature, whose value is chosen to ensure that the
+    sparse vector always sums to a constant non-negative number.  This
+    new feature is used to ensure two preconditions for the GIS
+    training algorithm:
+
+      - At least one feature vector index must be nonzero for every
+        token.
+      - The feature vector must sum to a constant non-negative number
+        for every token.
+    """
+
+    def __init__(
+        self, labels, mapping, unseen_features=False, alwayson_features=False, C=None
+    ):
+        """
+        :param C: The correction constant.  The value of the correction
+            feature is based on this value.  In particular, its value is
+            ``C - sum([v for (f,v) in encoding])``.
+        :seealso: ``BinaryMaxentFeatureEncoding.__init__``
+        """
+        BinaryMaxentFeatureEncoding.__init__(
+            self, labels, mapping, unseen_features, alwayson_features
+        )
+        if C is None:
+            C = len({fname for (fname, fval, label) in mapping}) + 1
+        self._C = C
+
+    @property
+    def C(self):
+        """The non-negative constant that all encoded feature vectors
+        will sum to."""
+        return self._C
+
+    def encode(self, featureset, label):
+        # Get the basic encoding.
+        encoding = BinaryMaxentFeatureEncoding.encode(self, featureset, label)
+        base_length = BinaryMaxentFeatureEncoding.length(self)
+
+        # Add a correction feature.
+        total = sum(v for (f, v) in encoding)
+        if total >= self._C:
+            raise ValueError("Correction feature is not high enough!")
+        encoding.append((base_length, self._C - total))
+
+        # Return the result
+        return encoding
+
+    def length(self):
+        return BinaryMaxentFeatureEncoding.length(self) + 1
+
+    def describe(self, f_id):
+        if f_id == BinaryMaxentFeatureEncoding.length(self):
+            return "Correction feature (%s)" % self._C
+        else:
+            return BinaryMaxentFeatureEncoding.describe(self, f_id)
+
+
+class TadmEventMaxentFeatureEncoding(BinaryMaxentFeatureEncoding):
+    def __init__(self, labels, mapping, unseen_features=False, alwayson_features=False):
+        self._mapping = OrderedDict(mapping)
+        self._label_mapping = OrderedDict()
+        BinaryMaxentFeatureEncoding.__init__(
+            self, labels, self._mapping, unseen_features, alwayson_features
+        )
+
+    def encode(self, featureset, label):
+        encoding = []
+        for feature, value in featureset.items():
+            if (feature, label) not in self._mapping:
+                self._mapping[(feature, label)] = len(self._mapping)
+            if value not in self._label_mapping:
+                if not isinstance(value, int):
+                    self._label_mapping[value] = len(self._label_mapping)
+                else:
+                    self._label_mapping[value] = value
+            encoding.append(
+                (self._mapping[(feature, label)], self._label_mapping[value])
+            )
+        return encoding
+
+    def labels(self):
+        return self._labels
+
+    def describe(self, fid):
+        for (feature, label) in self._mapping:
+            if self._mapping[(feature, label)] == fid:
+                return (feature, label)
+
+    def length(self):
+        return len(self._mapping)
+
+    @classmethod
+    def train(cls, train_toks, count_cutoff=0, labels=None, **options):
+        mapping = OrderedDict()
+        if not labels:
+            labels = []
+
+        # This gets read twice, so compute the values in case it's lazy.
+        train_toks = list(train_toks)
+
+        for (featureset, label) in train_toks:
+            if label not in labels:
+                labels.append(label)
+
+        for (featureset, label) in train_toks:
+            for label in labels:
+                for feature in featureset:
+                    if (feature, label) not in mapping:
+                        mapping[(feature, label)] = len(mapping)
+
+        return cls(labels, mapping, **options)
+
+
+class TypedMaxentFeatureEncoding(MaxentFeatureEncodingI):
+    """
+    A feature encoding that generates vectors containing integer,
+    float and binary joint-features of the form:
+
+    Binary (for string and boolean features):
+
+    |  joint_feat(fs, l) = { 1 if (fs[fname] == fval) and (l == label)
+    |                      {
+    |                      { 0 otherwise
+
+    Value (for integer and float features):
+
+    |  joint_feat(fs, l) = { fval if     (fs[fname] == type(fval))
+    |                      {         and (l == label)
+    |                      {
+    |                      { not encoded otherwise
+
+    Where ``fname`` is the name of an input-feature, ``fval`` is a value
+    for that input-feature, and ``label`` is a label.
+
+    Typically, these features are constructed based on a training
+    corpus, using the ``train()`` method.
+
+    For string and boolean features [type(fval) not in (int, float)]
+    this method will create one feature for each combination of
+    ``fname``, ``fval``, and ``label`` that occurs at least once in the
+    training corpus.
+
+    For integer and float features [type(fval) in (int, float)] this
+    method will create one feature for each combination of ``fname``
+    and ``label`` that occurs at least once in the training corpus.
+
+    For binary features the ``unseen_features`` parameter can be used
+    to add "unseen-value features", which are used whenever an input
+    feature has a value that was not encountered in the training
+    corpus.  These features have the form:
+
+    |  joint_feat(fs, l) = { 1 if is_unseen(fname, fs[fname])
+    |                      {      and l == label
+    |                      {
+    |                      { 0 otherwise
+
+    Where ``is_unseen(fname, fval)`` is true if the encoding does not
+    contain any joint features that are true when ``fs[fname]==fval``.
+
+    The ``alwayson_features`` parameter can be used to add "always-on
+    features", which have the form:
+
+    |  joint_feat(fs, l) = { 1 if (l == label)
+    |                      {
+    |                      { 0 otherwise
+
+    These always-on features allow the maxent model to directly model
+    the prior probabilities of each label.
+    """
+
+    def __init__(self, labels, mapping, unseen_features=False, alwayson_features=False):
+        """
+        :param labels: A list of the \"known labels\" for this encoding.
+
+        :param mapping: A dictionary mapping from ``(fname,fval,label)``
+            tuples to corresponding joint-feature indexes.  These
+            indexes must be the set of integers from 0...len(mapping).
+            If ``mapping[fname,fval,label]=id``, then
+            ``self.encode({..., fname:fval, ...``, label)[id]} is 1;
+            otherwise, it is 0.
+
+        :param unseen_features: If true, then include unseen value
+           features in the generated joint-feature vectors.
+
+        :param alwayson_features: If true, then include always-on
+           features in the generated joint-feature vectors.
+        """
+        if set(mapping.values()) != set(range(len(mapping))):
+            raise ValueError(
+                "Mapping values must be exactly the "
+                "set of integers from 0...len(mapping)"
+            )
+
+        self._labels = list(labels)
+        """A list of attested labels."""
+
+        self._mapping = mapping
+        """dict mapping from (fname,fval,label) -> fid"""
+
+        self._length = len(mapping)
+        """The length of generated joint feature vectors."""
+
+        self._alwayson = None
+        """dict mapping from label -> fid"""
+
+        self._unseen = None
+        """dict mapping from fname -> fid"""
+
+        if alwayson_features:
+            self._alwayson = {
+                label: i + self._length for (i, label) in enumerate(labels)
+            }
+            self._length += len(self._alwayson)
+
+        if unseen_features:
+            fnames = {fname for (fname, fval, label) in mapping}
+            self._unseen = {fname: i + self._length for (i, fname) in enumerate(fnames)}
+            self._length += len(fnames)
+
+    def encode(self, featureset, label):
+        # Inherit docs.
+        encoding = []
+
+        # Convert input-features to joint-features:
+        for fname, fval in featureset.items():
+            if isinstance(fval, (int, float)):
+                # Known feature name & value:
+                if (fname, type(fval), label) in self._mapping:
+                    encoding.append((self._mapping[fname, type(fval), label], fval))
+            else:
+                # Known feature name & value:
+                if (fname, fval, label) in self._mapping:
+                    encoding.append((self._mapping[fname, fval, label], 1))
+
+                # Otherwise, we might want to fire an "unseen-value feature".
+                elif self._unseen:
+                    # Have we seen this fname/fval combination with any label?
+                    for label2 in self._labels:
+                        if (fname, fval, label2) in self._mapping:
+                            break  # we've seen this fname/fval combo
+                    # We haven't -- fire the unseen-value feature
+                    else:
+                        if fname in self._unseen:
+                            encoding.append((self._unseen[fname], 1))
+
+        # Add always-on features:
+        if self._alwayson and label in self._alwayson:
+            encoding.append((self._alwayson[label], 1))
+
+        return encoding
+
+    def describe(self, f_id):
+        # Inherit docs.
+        if not isinstance(f_id, int):
+            raise TypeError("describe() expected an int")
+        try:
+            self._inv_mapping
+        except AttributeError:
+            self._inv_mapping = [-1] * len(self._mapping)
+            for (info, i) in self._mapping.items():
+                self._inv_mapping[i] = info
+
+        if f_id < len(self._mapping):
+            (fname, fval, label) = self._inv_mapping[f_id]
+            return f"{fname}=={fval!r} and label is {label!r}"
+        elif self._alwayson and f_id in self._alwayson.values():
+            for (label, f_id2) in self._alwayson.items():
+                if f_id == f_id2:
+                    return "label is %r" % label
+        elif self._unseen and f_id in self._unseen.values():
+            for (fname, f_id2) in self._unseen.items():
+                if f_id == f_id2:
+                    return "%s is unseen" % fname
+        else:
+            raise ValueError("Bad feature id")
+
+    def labels(self):
+        # Inherit docs.
+        return self._labels
+
+    def length(self):
+        # Inherit docs.
+        return self._length
+
+    @classmethod
+    def train(cls, train_toks, count_cutoff=0, labels=None, **options):
+        """
+        Construct and return new feature encoding, based on a given
+        training corpus ``train_toks``.  See the class description
+        ``TypedMaxentFeatureEncoding`` for a description of the
+        joint-features that will be included in this encoding.
+
+        Note: recognized feature values types are (int, float), over
+        types are interpreted as regular binary features.
+
+        :type train_toks: list(tuple(dict, str))
+        :param train_toks: Training data, represented as a list of
+            pairs, the first member of which is a feature dictionary,
+            and the second of which is a classification label.
+
+        :type count_cutoff: int
+        :param count_cutoff: A cutoff value that is used to discard
+            rare joint-features.  If a joint-feature's value is 1
+            fewer than ``count_cutoff`` times in the training corpus,
+            then that joint-feature is not included in the generated
+            encoding.
+
+        :type labels: list
+        :param labels: A list of labels that should be used by the
+            classifier.  If not specified, then the set of labels
+            attested in ``train_toks`` will be used.
+
+        :param options: Extra parameters for the constructor, such as
+            ``unseen_features`` and ``alwayson_features``.
+        """
+        mapping = {}  # maps (fname, fval, label) -> fid
+        seen_labels = set()  # The set of labels we've encountered
+        count = defaultdict(int)  # maps (fname, fval) -> count
+
+        for (tok, label) in train_toks:
+            if labels and label not in labels:
+                raise ValueError("Unexpected label %s" % label)
+            seen_labels.add(label)
+
+            # Record each of the features.
+            for (fname, fval) in tok.items():
+                if type(fval) in (int, float):
+                    fval = type(fval)
+                # If a count cutoff is given, then only add a joint
+                # feature once the corresponding (fname, fval, label)
+                # tuple exceeds that cutoff.
+                count[fname, fval] += 1
+                if count[fname, fval] >= count_cutoff:
+                    if (fname, fval, label) not in mapping:
+                        mapping[fname, fval, label] = len(mapping)
+
+        if labels is None:
+            labels = seen_labels
+        return cls(labels, mapping, **options)
+
+
+######################################################################
+# { Classifier Trainer: Generalized Iterative Scaling
+######################################################################
+
+
+def train_maxent_classifier_with_gis(
+    train_toks, trace=3, encoding=None, labels=None, **cutoffs
+):
+    """
+    Train a new ``ConditionalExponentialClassifier``, using the given
+    training samples, using the Generalized Iterative Scaling
+    algorithm.  This ``ConditionalExponentialClassifier`` will encode
+    the model that maximizes entropy from all the models that are
+    empirically consistent with ``train_toks``.
+
+    :see: ``train_maxent_classifier()`` for parameter descriptions.
+    """
+    cutoffs.setdefault("max_iter", 100)
+    cutoffchecker = CutoffChecker(cutoffs)
+
+    # Construct an encoding from the training data.
+    if encoding is None:
+        encoding = GISEncoding.train(train_toks, labels=labels)
+
+    if not hasattr(encoding, "C"):
+        raise TypeError(
+            "The GIS algorithm requires an encoding that "
+            "defines C (e.g., GISEncoding)."
+        )
+
+    # Cinv is the inverse of the sum of each joint feature vector.
+    # This controls the learning rate: higher Cinv (or lower C) gives
+    # faster learning.
+    Cinv = 1.0 / encoding.C
+
+    # Count how many times each feature occurs in the training data.
+    empirical_fcount = calculate_empirical_fcount(train_toks, encoding)
+
+    # Check for any features that are not attested in train_toks.
+    unattested = set(numpy.nonzero(empirical_fcount == 0)[0])
+
+    # Build the classifier.  Start with weight=0 for each attested
+    # feature, and weight=-infinity for each unattested feature.
+    weights = numpy.zeros(len(empirical_fcount), "d")
+    for fid in unattested:
+        weights[fid] = numpy.NINF
+    classifier = ConditionalExponentialClassifier(encoding, weights)
+
+    # Take the log of the empirical fcount.
+    log_empirical_fcount = numpy.log2(empirical_fcount)
+    del empirical_fcount
+
+    if trace > 0:
+        print("  ==> Training (%d iterations)" % cutoffs["max_iter"])
+    if trace > 2:
+        print()
+        print("      Iteration    Log Likelihood    Accuracy")
+        print("      ---------------------------------------")
+
+    # Train the classifier.
+    try:
+        while True:
+            if trace > 2:
+                ll = cutoffchecker.ll or log_likelihood(classifier, train_toks)
+                acc = cutoffchecker.acc or accuracy(classifier, train_toks)
+                iternum = cutoffchecker.iter
+                print("     %9d    %14.5f    %9.3f" % (iternum, ll, acc))
+
+            # Use the model to estimate the number of times each
+            # feature should occur in the training data.
+            estimated_fcount = calculate_estimated_fcount(
+                classifier, train_toks, encoding
+            )
+
+            # Take the log of estimated fcount (avoid taking log(0).)
+            for fid in unattested:
+                estimated_fcount[fid] += 1
+            log_estimated_fcount = numpy.log2(estimated_fcount)
+            del estimated_fcount
+
+            # Update the classifier weights
+            weights = classifier.weights()
+            weights += (log_empirical_fcount - log_estimated_fcount) * Cinv
+            classifier.set_weights(weights)
+
+            # Check the log-likelihood & accuracy cutoffs.
+            if cutoffchecker.check(classifier, train_toks):
+                break
+
+    except KeyboardInterrupt:
+        print("      Training stopped: keyboard interrupt")
+    except:
+        raise
+
+    if trace > 2:
+        ll = log_likelihood(classifier, train_toks)
+        acc = accuracy(classifier, train_toks)
+        print(f"         Final    {ll:14.5f}    {acc:9.3f}")
+
+    # Return the classifier.
+    return classifier
+
+
+def calculate_empirical_fcount(train_toks, encoding):
+    fcount = numpy.zeros(encoding.length(), "d")
+
+    for tok, label in train_toks:
+        for (index, val) in encoding.encode(tok, label):
+            fcount[index] += val
+
+    return fcount
+
+
+def calculate_estimated_fcount(classifier, train_toks, encoding):
+    fcount = numpy.zeros(encoding.length(), "d")
+
+    for tok, label in train_toks:
+        pdist = classifier.prob_classify(tok)
+        for label in pdist.samples():
+            prob = pdist.prob(label)
+            for (fid, fval) in encoding.encode(tok, label):
+                fcount[fid] += prob * fval
+
+    return fcount
+
+
+######################################################################
+# { Classifier Trainer: Improved Iterative Scaling
+######################################################################
+
+
+def train_maxent_classifier_with_iis(
+    train_toks, trace=3, encoding=None, labels=None, **cutoffs
+):
+    """
+    Train a new ``ConditionalExponentialClassifier``, using the given
+    training samples, using the Improved Iterative Scaling algorithm.
+    This ``ConditionalExponentialClassifier`` will encode the model
+    that maximizes entropy from all the models that are empirically
+    consistent with ``train_toks``.
+
+    :see: ``train_maxent_classifier()`` for parameter descriptions.
+    """
+    cutoffs.setdefault("max_iter", 100)
+    cutoffchecker = CutoffChecker(cutoffs)
+
+    # Construct an encoding from the training data.
+    if encoding is None:
+        encoding = BinaryMaxentFeatureEncoding.train(train_toks, labels=labels)
+
+    # Count how many times each feature occurs in the training data.
+    empirical_ffreq = calculate_empirical_fcount(train_toks, encoding) / len(train_toks)
+
+    # Find the nf map, and related variables nfarray and nfident.
+    # nf is the sum of the features for a given labeled text.
+    # nfmap compresses this sparse set of values to a dense list.
+    # nfarray performs the reverse operation.  nfident is
+    # nfarray multiplied by an identity matrix.
+    nfmap = calculate_nfmap(train_toks, encoding)
+    nfarray = numpy.array(sorted(nfmap, key=nfmap.__getitem__), "d")
+    nftranspose = numpy.reshape(nfarray, (len(nfarray), 1))
+
+    # Check for any features that are not attested in train_toks.
+    unattested = set(numpy.nonzero(empirical_ffreq == 0)[0])
+
+    # Build the classifier.  Start with weight=0 for each attested
+    # feature, and weight=-infinity for each unattested feature.
+    weights = numpy.zeros(len(empirical_ffreq), "d")
+    for fid in unattested:
+        weights[fid] = numpy.NINF
+    classifier = ConditionalExponentialClassifier(encoding, weights)
+
+    if trace > 0:
+        print("  ==> Training (%d iterations)" % cutoffs["max_iter"])
+    if trace > 2:
+        print()
+        print("      Iteration    Log Likelihood    Accuracy")
+        print("      ---------------------------------------")
+
+    # Train the classifier.
+    try:
+        while True:
+            if trace > 2:
+                ll = cutoffchecker.ll or log_likelihood(classifier, train_toks)
+                acc = cutoffchecker.acc or accuracy(classifier, train_toks)
+                iternum = cutoffchecker.iter
+                print("     %9d    %14.5f    %9.3f" % (iternum, ll, acc))
+
+            # Calculate the deltas for this iteration, using Newton's method.
+            deltas = calculate_deltas(
+                train_toks,
+                classifier,
+                unattested,
+                empirical_ffreq,
+                nfmap,
+                nfarray,
+                nftranspose,
+                encoding,
+            )
+
+            # Use the deltas to update our weights.
+            weights = classifier.weights()
+            weights += deltas
+            classifier.set_weights(weights)
+
+            # Check the log-likelihood & accuracy cutoffs.
+            if cutoffchecker.check(classifier, train_toks):
+                break
+
+    except KeyboardInterrupt:
+        print("      Training stopped: keyboard interrupt")
+    except:
+        raise
+
+    if trace > 2:
+        ll = log_likelihood(classifier, train_toks)
+        acc = accuracy(classifier, train_toks)
+        print(f"         Final    {ll:14.5f}    {acc:9.3f}")
+
+    # Return the classifier.
+    return classifier
+
+
+def calculate_nfmap(train_toks, encoding):
+    """
+    Construct a map that can be used to compress ``nf`` (which is
+    typically sparse).
+
+    *nf(feature_vector)* is the sum of the feature values for
+    *feature_vector*.
+
+    This represents the number of features that are active for a
+    given labeled text.  This method finds all values of *nf(t)*
+    that are attested for at least one token in the given list of
+    training tokens; and constructs a dictionary mapping these
+    attested values to a continuous range *0...N*.  For example,
+    if the only values of *nf()* that were attested were 3, 5, and
+    7, then ``_nfmap`` might return the dictionary ``{3:0, 5:1, 7:2}``.
+
+    :return: A map that can be used to compress ``nf`` to a dense
+        vector.
+    :rtype: dict(int -> int)
+    """
+    # Map from nf to indices.  This allows us to use smaller arrays.
+    nfset = set()
+    for tok, _ in train_toks:
+        for label in encoding.labels():
+            nfset.add(sum(val for (id, val) in encoding.encode(tok, label)))
+    return {nf: i for (i, nf) in enumerate(nfset)}
+
+
+def calculate_deltas(
+    train_toks,
+    classifier,
+    unattested,
+    ffreq_empirical,
+    nfmap,
+    nfarray,
+    nftranspose,
+    encoding,
+):
+    r"""
+    Calculate the update values for the classifier weights for
+    this iteration of IIS.  These update weights are the value of
+    ``delta`` that solves the equation::
+
+      ffreq_empirical[i]
+             =
+      SUM[fs,l] (classifier.prob_classify(fs).prob(l) *
+                 feature_vector(fs,l)[i] *
+                 exp(delta[i] * nf(feature_vector(fs,l))))
+
+    Where:
+        - *(fs,l)* is a (featureset, label) tuple from ``train_toks``
+        - *feature_vector(fs,l)* = ``encoding.encode(fs,l)``
+        - *nf(vector)* = ``sum([val for (id,val) in vector])``
+
+    This method uses Newton's method to solve this equation for
+    *delta[i]*.  In particular, it starts with a guess of
+    ``delta[i]`` = 1; and iteratively updates ``delta`` with:
+
+    | delta[i] -= (ffreq_empirical[i] - sum1[i])/(-sum2[i])
+
+    until convergence, where *sum1* and *sum2* are defined as:
+
+    |    sum1[i](delta) = SUM[fs,l] f[i](fs,l,delta)
+    |    sum2[i](delta) = SUM[fs,l] (f[i](fs,l,delta).nf(feature_vector(fs,l)))
+    |    f[i](fs,l,delta) = (classifier.prob_classify(fs).prob(l) .
+    |                        feature_vector(fs,l)[i] .
+    |                        exp(delta[i] . nf(feature_vector(fs,l))))
+
+    Note that *sum1* and *sum2* depend on ``delta``; so they need
+    to be re-computed each iteration.
+
+    The variables ``nfmap``, ``nfarray``, and ``nftranspose`` are
+    used to generate a dense encoding for *nf(ltext)*.  This
+    allows ``_deltas`` to calculate *sum1* and *sum2* using
+    matrices, which yields a significant performance improvement.
+
+    :param train_toks: The set of training tokens.
+    :type train_toks: list(tuple(dict, str))
+    :param classifier: The current classifier.
+    :type classifier: ClassifierI
+    :param ffreq_empirical: An array containing the empirical
+        frequency for each feature.  The *i*\ th element of this
+        array is the empirical frequency for feature *i*.
+    :type ffreq_empirical: sequence of float
+    :param unattested: An array that is 1 for features that are
+        not attested in the training data; and 0 for features that
+        are attested.  In other words, ``unattested[i]==0`` iff
+        ``ffreq_empirical[i]==0``.
+    :type unattested: sequence of int
+    :param nfmap: A map that can be used to compress ``nf`` to a dense
+        vector.
+    :type nfmap: dict(int -> int)
+    :param nfarray: An array that can be used to uncompress ``nf``
+        from a dense vector.
+    :type nfarray: array(float)
+    :param nftranspose: The transpose of ``nfarray``
+    :type nftranspose: array(float)
+    """
+    # These parameters control when we decide that we've
+    # converged.  It probably should be possible to set these
+    # manually, via keyword arguments to train.
+    NEWTON_CONVERGE = 1e-12
+    MAX_NEWTON = 300
+
+    deltas = numpy.ones(encoding.length(), "d")
+
+    # Precompute the A matrix:
+    # A[nf][id] = sum ( p(fs) * p(label|fs) * f(fs,label) )
+    # over all label,fs s.t. num_features[label,fs]=nf
+    A = numpy.zeros((len(nfmap), encoding.length()), "d")
+
+    for tok, label in train_toks:
+        dist = classifier.prob_classify(tok)
+
+        for label in encoding.labels():
+            # Generate the feature vector
+            feature_vector = encoding.encode(tok, label)
+            # Find the number of active features
+            nf = sum(val for (id, val) in feature_vector)
+            # Update the A matrix
+            for (id, val) in feature_vector:
+                A[nfmap[nf], id] += dist.prob(label) * val
+    A /= len(train_toks)
+
+    # Iteratively solve for delta.  Use the following variables:
+    #   - nf_delta[x][y] = nfarray[x] * delta[y]
+    #   - exp_nf_delta[x][y] = exp(nf[x] * delta[y])
+    #   - nf_exp_nf_delta[x][y] = nf[x] * exp(nf[x] * delta[y])
+    #   - sum1[i][nf] = sum p(fs)p(label|fs)f[i](label,fs)
+    #                       exp(delta[i]nf)
+    #   - sum2[i][nf] = sum p(fs)p(label|fs)f[i](label,fs)
+    #                       nf exp(delta[i]nf)
+    for rangenum in range(MAX_NEWTON):
+        nf_delta = numpy.outer(nfarray, deltas)
+        exp_nf_delta = 2**nf_delta
+        nf_exp_nf_delta = nftranspose * exp_nf_delta
+        sum1 = numpy.sum(exp_nf_delta * A, axis=0)
+        sum2 = numpy.sum(nf_exp_nf_delta * A, axis=0)
+
+        # Avoid division by zero.
+        for fid in unattested:
+            sum2[fid] += 1
+
+        # Update the deltas.
+        deltas -= (ffreq_empirical - sum1) / -sum2
+
+        # We can stop once we converge.
+        n_error = numpy.sum(abs(ffreq_empirical - sum1)) / numpy.sum(abs(deltas))
+        if n_error < NEWTON_CONVERGE:
+            return deltas
+
+    return deltas
+
+
+######################################################################
+# { Classifier Trainer: megam
+######################################################################
+
+# [xx] possible extension: add support for using implicit file format;
+# this would need to put requirements on what encoding is used.  But
+# we may need this for other maxent classifier trainers that require
+# implicit formats anyway.
+def train_maxent_classifier_with_megam(
+    train_toks, trace=3, encoding=None, labels=None, gaussian_prior_sigma=0, **kwargs
+):
+    """
+    Train a new ``ConditionalExponentialClassifier``, using the given
+    training samples, using the external ``megam`` library.  This
+    ``ConditionalExponentialClassifier`` will encode the model that
+    maximizes entropy from all the models that are empirically
+    consistent with ``train_toks``.
+
+    :see: ``train_maxent_classifier()`` for parameter descriptions.
+    :see: ``nltk.classify.megam``
+    """
+
+    explicit = True
+    bernoulli = True
+    if "explicit" in kwargs:
+        explicit = kwargs["explicit"]
+    if "bernoulli" in kwargs:
+        bernoulli = kwargs["bernoulli"]
+
+    # Construct an encoding from the training data.
+    if encoding is None:
+        # Count cutoff can also be controlled by megam with the -minfc
+        # option. Not sure where the best place for it is.
+        count_cutoff = kwargs.get("count_cutoff", 0)
+        encoding = BinaryMaxentFeatureEncoding.train(
+            train_toks, count_cutoff, labels=labels, alwayson_features=True
+        )
+    elif labels is not None:
+        raise ValueError("Specify encoding or labels, not both")
+
+    # Write a training file for megam.
+    try:
+        fd, trainfile_name = tempfile.mkstemp(prefix="nltk-")
+        with open(trainfile_name, "w") as trainfile:
+            write_megam_file(
+                train_toks, encoding, trainfile, explicit=explicit, bernoulli=bernoulli
+            )
+        os.close(fd)
+    except (OSError, ValueError) as e:
+        raise ValueError("Error while creating megam training file: %s" % e) from e
+
+    # Run megam on the training file.
+    options = []
+    options += ["-nobias", "-repeat", "10"]
+    if explicit:
+        options += ["-explicit"]
+    if not bernoulli:
+        options += ["-fvals"]
+    if gaussian_prior_sigma:
+        # Lambda is just the precision of the Gaussian prior, i.e. it's the
+        # inverse variance, so the parameter conversion is 1.0/sigma**2.
+        # See https://users.umiacs.umd.edu/~hal/docs/daume04cg-bfgs.pdf
+        inv_variance = 1.0 / gaussian_prior_sigma**2
+    else:
+        inv_variance = 0
+    options += ["-lambda", "%.2f" % inv_variance, "-tune"]
+    if trace < 3:
+        options += ["-quiet"]
+    if "max_iter" in kwargs:
+        options += ["-maxi", "%s" % kwargs["max_iter"]]
+    if "ll_delta" in kwargs:
+        # [xx] this is actually a perplexity delta, not a log
+        # likelihood delta
+        options += ["-dpp", "%s" % abs(kwargs["ll_delta"])]
+    if hasattr(encoding, "cost"):
+        options += ["-multilabel"]  # each possible la
+    options += ["multiclass", trainfile_name]
+    stdout = call_megam(options)
+    # print('./megam_i686.opt ', ' '.join(options))
+    # Delete the training file
+    try:
+        os.remove(trainfile_name)
+    except OSError as e:
+        print(f"Warning: unable to delete {trainfile_name}: {e}")
+
+    # Parse the generated weight vector.
+    weights = parse_megam_weights(stdout, encoding.length(), explicit)
+
+    # Convert from base-e to base-2 weights.
+    weights *= numpy.log2(numpy.e)
+
+    # Build the classifier
+    return MaxentClassifier(encoding, weights)
+
+
+######################################################################
+# { Classifier Trainer: tadm
+######################################################################
+
+
+class TadmMaxentClassifier(MaxentClassifier):
+    @classmethod
+    def train(cls, train_toks, **kwargs):
+        algorithm = kwargs.get("algorithm", "tao_lmvm")
+        trace = kwargs.get("trace", 3)
+        encoding = kwargs.get("encoding", None)
+        labels = kwargs.get("labels", None)
+        sigma = kwargs.get("gaussian_prior_sigma", 0)
+        count_cutoff = kwargs.get("count_cutoff", 0)
+        max_iter = kwargs.get("max_iter")
+        ll_delta = kwargs.get("min_lldelta")
+
+        # Construct an encoding from the training data.
+        if not encoding:
+            encoding = TadmEventMaxentFeatureEncoding.train(
+                train_toks, count_cutoff, labels=labels
+            )
+
+        trainfile_fd, trainfile_name = tempfile.mkstemp(
+            prefix="nltk-tadm-events-", suffix=".gz"
+        )
+        weightfile_fd, weightfile_name = tempfile.mkstemp(prefix="nltk-tadm-weights-")
+
+        trainfile = gzip_open_unicode(trainfile_name, "w")
+        write_tadm_file(train_toks, encoding, trainfile)
+        trainfile.close()
+
+        options = []
+        options.extend(["-monitor"])
+        options.extend(["-method", algorithm])
+        if sigma:
+            options.extend(["-l2", "%.6f" % sigma**2])
+        if max_iter:
+            options.extend(["-max_it", "%d" % max_iter])
+        if ll_delta:
+            options.extend(["-fatol", "%.6f" % abs(ll_delta)])
+        options.extend(["-events_in", trainfile_name])
+        options.extend(["-params_out", weightfile_name])
+        if trace < 3:
+            options.extend(["2>&1"])
+        else:
+            options.extend(["-summary"])
+
+        call_tadm(options)
+
+        with open(weightfile_name) as weightfile:
+            weights = parse_tadm_weights(weightfile)
+
+        os.remove(trainfile_name)
+        os.remove(weightfile_name)
+
+        # Convert from base-e to base-2 weights.
+        weights *= numpy.log2(numpy.e)
+
+        # Build the classifier
+        return cls(encoding, weights)
+
+
+######################################################################
+# { Demo
+######################################################################
+def demo():
+    from nltk.classify.util import names_demo
+
+    classifier = names_demo(MaxentClassifier.train)
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/classify/megam.py

@@ -0,0 +1,184 @@
+# Natural Language Toolkit: Interface to Megam Classifier
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A set of functions used to interface with the external megam_ maxent
+optimization package. Before megam can be used, you should tell NLTK where it
+can find the megam binary, using the ``config_megam()`` function. Typical
+usage:
+
+    >>> from nltk.classify import megam
+    >>> megam.config_megam() # pass path to megam if not found in PATH # doctest: +SKIP
+    [Found megam: ...]
+
+Use with MaxentClassifier. Example below, see MaxentClassifier documentation
+for details.
+
+    nltk.classify.MaxentClassifier.train(corpus, 'megam')
+
+.. _megam: https://www.umiacs.umd.edu/~hal/megam/index.html
+"""
+import subprocess
+
+from nltk.internals import find_binary
+
+try:
+    import numpy
+except ImportError:
+    numpy = None
+
+######################################################################
+# { Configuration
+######################################################################
+
+_megam_bin = None
+
+
+def config_megam(bin=None):
+    """
+    Configure NLTK's interface to the ``megam`` maxent optimization
+    package.
+
+    :param bin: The full path to the ``megam`` binary.  If not specified,
+        then nltk will search the system for a ``megam`` binary; and if
+        one is not found, it will raise a ``LookupError`` exception.
+    :type bin: str
+    """
+    global _megam_bin
+    _megam_bin = find_binary(
+        "megam",
+        bin,
+        env_vars=["MEGAM"],
+        binary_names=["megam.opt", "megam", "megam_686", "megam_i686.opt"],
+        url="https://www.umiacs.umd.edu/~hal/megam/index.html",
+    )
+
+
+######################################################################
+# { Megam Interface Functions
+######################################################################
+
+
+def write_megam_file(train_toks, encoding, stream, bernoulli=True, explicit=True):
+    """
+    Generate an input file for ``megam`` based on the given corpus of
+    classified tokens.
+
+    :type train_toks: list(tuple(dict, str))
+    :param train_toks: Training data, represented as a list of
+        pairs, the first member of which is a feature dictionary,
+        and the second of which is a classification label.
+
+    :type encoding: MaxentFeatureEncodingI
+    :param encoding: A feature encoding, used to convert featuresets
+        into feature vectors. May optionally implement a cost() method
+        in order to assign different costs to different class predictions.
+
+    :type stream: stream
+    :param stream: The stream to which the megam input file should be
+        written.
+
+    :param bernoulli: If true, then use the 'bernoulli' format.  I.e.,
+        all joint features have binary values, and are listed iff they
+        are true.  Otherwise, list feature values explicitly.  If
+        ``bernoulli=False``, then you must call ``megam`` with the
+        ``-fvals`` option.
+
+    :param explicit: If true, then use the 'explicit' format.  I.e.,
+        list the features that would fire for any of the possible
+        labels, for each token.  If ``explicit=True``, then you must
+        call ``megam`` with the ``-explicit`` option.
+    """
+    # Look up the set of labels.
+    labels = encoding.labels()
+    labelnum = {label: i for (i, label) in enumerate(labels)}
+
+    # Write the file, which contains one line per instance.
+    for featureset, label in train_toks:
+        # First, the instance number (or, in the weighted multiclass case, the cost of each label).
+        if hasattr(encoding, "cost"):
+            stream.write(
+                ":".join(str(encoding.cost(featureset, label, l)) for l in labels)
+            )
+        else:
+            stream.write("%d" % labelnum[label])
+
+        # For implicit file formats, just list the features that fire
+        # for this instance's actual label.
+        if not explicit:
+            _write_megam_features(encoding.encode(featureset, label), stream, bernoulli)
+
+        # For explicit formats, list the features that would fire for
+        # any of the possible labels.
+        else:
+            for l in labels:
+                stream.write(" #")
+                _write_megam_features(encoding.encode(featureset, l), stream, bernoulli)
+
+        # End of the instance.
+        stream.write("\n")
+
+
+def parse_megam_weights(s, features_count, explicit=True):
+    """
+    Given the stdout output generated by ``megam`` when training a
+    model, return a ``numpy`` array containing the corresponding weight
+    vector.  This function does not currently handle bias features.
+    """
+    if numpy is None:
+        raise ValueError("This function requires that numpy be installed")
+    assert explicit, "non-explicit not supported yet"
+    lines = s.strip().split("\n")
+    weights = numpy.zeros(features_count, "d")
+    for line in lines:
+        if line.strip():
+            fid, weight = line.split()
+            weights[int(fid)] = float(weight)
+    return weights
+
+
+def _write_megam_features(vector, stream, bernoulli):
+    if not vector:
+        raise ValueError(
+            "MEGAM classifier requires the use of an " "always-on feature."
+        )
+    for (fid, fval) in vector:
+        if bernoulli:
+            if fval == 1:
+                stream.write(" %s" % fid)
+            elif fval != 0:
+                raise ValueError(
+                    "If bernoulli=True, then all" "features must be binary."
+                )
+        else:
+            stream.write(f" {fid} {fval}")
+
+
+def call_megam(args):
+    """
+    Call the ``megam`` binary with the given arguments.
+    """
+    if isinstance(args, str):
+        raise TypeError("args should be a list of strings")
+    if _megam_bin is None:
+        config_megam()
+
+    # Call megam via a subprocess
+    cmd = [_megam_bin] + args
+    p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
+    (stdout, stderr) = p.communicate()
+
+    # Check the return code.
+    if p.returncode != 0:
+        print()
+        print(stderr)
+        raise OSError("megam command failed!")
+
+    if isinstance(stdout, str):
+        return stdout
+    else:
+        return stdout.decode("utf-8")

env-llmeval/lib/python3.10/site-packages/nltk/classify/naivebayes.py

@@ -0,0 +1,260 @@
+# Natural Language Toolkit: Naive Bayes Classifiers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A classifier based on the Naive Bayes algorithm.  In order to find the
+probability for a label, this algorithm first uses the Bayes rule to
+express P(label|features) in terms of P(label) and P(features|label):
+
+|                       P(label) * P(features|label)
+|  P(label|features) = ------------------------------
+|                              P(features)
+
+The algorithm then makes the 'naive' assumption that all features are
+independent, given the label:
+
+|                       P(label) * P(f1|label) * ... * P(fn|label)
+|  P(label|features) = --------------------------------------------
+|                                         P(features)
+
+Rather than computing P(features) explicitly, the algorithm just
+calculates the numerator for each label, and normalizes them so they
+sum to one:
+
+|                       P(label) * P(f1|label) * ... * P(fn|label)
+|  P(label|features) = --------------------------------------------
+|                        SUM[l]( P(l) * P(f1|l) * ... * P(fn|l) )
+"""
+
+from collections import defaultdict
+
+from nltk.classify.api import ClassifierI
+from nltk.probability import DictionaryProbDist, ELEProbDist, FreqDist, sum_logs
+
+##//////////////////////////////////////////////////////
+##  Naive Bayes Classifier
+##//////////////////////////////////////////////////////
+
+
+class NaiveBayesClassifier(ClassifierI):
+    """
+    A Naive Bayes classifier.  Naive Bayes classifiers are
+    paramaterized by two probability distributions:
+
+      - P(label) gives the probability that an input will receive each
+        label, given no information about the input's features.
+
+      - P(fname=fval|label) gives the probability that a given feature
+        (fname) will receive a given value (fval), given that the
+        label (label).
+
+    If the classifier encounters an input with a feature that has
+    never been seen with any label, then rather than assigning a
+    probability of 0 to all labels, it will ignore that feature.
+
+    The feature value 'None' is reserved for unseen feature values;
+    you generally should not use 'None' as a feature value for one of
+    your own features.
+    """
+
+    def __init__(self, label_probdist, feature_probdist):
+        """
+        :param label_probdist: P(label), the probability distribution
+            over labels.  It is expressed as a ``ProbDistI`` whose
+            samples are labels.  I.e., P(label) =
+            ``label_probdist.prob(label)``.
+
+        :param feature_probdist: P(fname=fval|label), the probability
+            distribution for feature values, given labels.  It is
+            expressed as a dictionary whose keys are ``(label, fname)``
+            pairs and whose values are ``ProbDistI`` objects over feature
+            values.  I.e., P(fname=fval|label) =
+            ``feature_probdist[label,fname].prob(fval)``.  If a given
+            ``(label,fname)`` is not a key in ``feature_probdist``, then
+            it is assumed that the corresponding P(fname=fval|label)
+            is 0 for all values of ``fval``.
+        """
+        self._label_probdist = label_probdist
+        self._feature_probdist = feature_probdist
+        self._labels = list(label_probdist.samples())
+
+    def labels(self):
+        return self._labels
+
+    def classify(self, featureset):
+        return self.prob_classify(featureset).max()
+
+    def prob_classify(self, featureset):
+        # Discard any feature names that we've never seen before.
+        # Otherwise, we'll just assign a probability of 0 to
+        # everything.
+        featureset = featureset.copy()
+        for fname in list(featureset.keys()):
+            for label in self._labels:
+                if (label, fname) in self._feature_probdist:
+                    break
+            else:
+                # print('Ignoring unseen feature %s' % fname)
+                del featureset[fname]
+
+        # Find the log probability of each label, given the features.
+        # Start with the log probability of the label itself.
+        logprob = {}
+        for label in self._labels:
+            logprob[label] = self._label_probdist.logprob(label)
+
+        # Then add in the log probability of features given labels.
+        for label in self._labels:
+            for (fname, fval) in featureset.items():
+                if (label, fname) in self._feature_probdist:
+                    feature_probs = self._feature_probdist[label, fname]
+                    logprob[label] += feature_probs.logprob(fval)
+                else:
+                    # nb: This case will never come up if the
+                    # classifier was created by
+                    # NaiveBayesClassifier.train().
+                    logprob[label] += sum_logs([])  # = -INF.
+
+        return DictionaryProbDist(logprob, normalize=True, log=True)
+
+    def show_most_informative_features(self, n=10):
+        # Determine the most relevant features, and display them.
+        cpdist = self._feature_probdist
+        print("Most Informative Features")
+
+        for (fname, fval) in self.most_informative_features(n):
+
+            def labelprob(l):
+                return cpdist[l, fname].prob(fval)
+
+            labels = sorted(
+                (l for l in self._labels if fval in cpdist[l, fname].samples()),
+                key=lambda element: (-labelprob(element), element),
+                reverse=True,
+            )
+            if len(labels) == 1:
+                continue
+            l0 = labels[0]
+            l1 = labels[-1]
+            if cpdist[l0, fname].prob(fval) == 0:
+                ratio = "INF"
+            else:
+                ratio = "%8.1f" % (
+                    cpdist[l1, fname].prob(fval) / cpdist[l0, fname].prob(fval)
+                )
+            print(
+                "%24s = %-14r %6s : %-6s = %s : 1.0"
+                % (fname, fval, ("%s" % l1)[:6], ("%s" % l0)[:6], ratio)
+            )
+
+    def most_informative_features(self, n=100):
+        """
+        Return a list of the 'most informative' features used by this
+        classifier.  For the purpose of this function, the
+        informativeness of a feature ``(fname,fval)`` is equal to the
+        highest value of P(fname=fval|label), for any label, divided by
+        the lowest value of P(fname=fval|label), for any label:
+
+        |  max[ P(fname=fval|label1) / P(fname=fval|label2) ]
+        """
+        if hasattr(self, "_most_informative_features"):
+            return self._most_informative_features[:n]
+        else:
+            # The set of (fname, fval) pairs used by this classifier.
+            features = set()
+            # The max & min probability associated w/ each (fname, fval)
+            # pair.  Maps (fname,fval) -> float.
+            maxprob = defaultdict(lambda: 0.0)
+            minprob = defaultdict(lambda: 1.0)
+
+            for (label, fname), probdist in self._feature_probdist.items():
+                for fval in probdist.samples():
+                    feature = (fname, fval)
+                    features.add(feature)
+                    p = probdist.prob(fval)
+                    maxprob[feature] = max(p, maxprob[feature])
+                    minprob[feature] = min(p, minprob[feature])
+                    if minprob[feature] == 0:
+                        features.discard(feature)
+
+            # Convert features to a list, & sort it by how informative
+            # features are.
+            self._most_informative_features = sorted(
+                features,
+                key=lambda feature_: (
+                    minprob[feature_] / maxprob[feature_],
+                    feature_[0],
+                    feature_[1] in [None, False, True],
+                    str(feature_[1]).lower(),
+                ),
+            )
+        return self._most_informative_features[:n]
+
+    @classmethod
+    def train(cls, labeled_featuresets, estimator=ELEProbDist):
+        """
+        :param labeled_featuresets: A list of classified featuresets,
+            i.e., a list of tuples ``(featureset, label)``.
+        """
+        label_freqdist = FreqDist()
+        feature_freqdist = defaultdict(FreqDist)
+        feature_values = defaultdict(set)
+        fnames = set()
+
+        # Count up how many times each feature value occurred, given
+        # the label and featurename.
+        for featureset, label in labeled_featuresets:
+            label_freqdist[label] += 1
+            for fname, fval in featureset.items():
+                # Increment freq(fval|label, fname)
+                feature_freqdist[label, fname][fval] += 1
+                # Record that fname can take the value fval.
+                feature_values[fname].add(fval)
+                # Keep a list of all feature names.
+                fnames.add(fname)
+
+        # If a feature didn't have a value given for an instance, then
+        # we assume that it gets the implicit value 'None.'  This loop
+        # counts up the number of 'missing' feature values for each
+        # (label,fname) pair, and increments the count of the fval
+        # 'None' by that amount.
+        for label in label_freqdist:
+            num_samples = label_freqdist[label]
+            for fname in fnames:
+                count = feature_freqdist[label, fname].N()
+                # Only add a None key when necessary, i.e. if there are
+                # any samples with feature 'fname' missing.
+                if num_samples - count > 0:
+                    feature_freqdist[label, fname][None] += num_samples - count
+                    feature_values[fname].add(None)
+
+        # Create the P(label) distribution
+        label_probdist = estimator(label_freqdist)
+
+        # Create the P(fval|label, fname) distribution
+        feature_probdist = {}
+        for ((label, fname), freqdist) in feature_freqdist.items():
+            probdist = estimator(freqdist, bins=len(feature_values[fname]))
+            feature_probdist[label, fname] = probdist
+
+        return cls(label_probdist, feature_probdist)
+
+
+##//////////////////////////////////////////////////////
+##  Demo
+##//////////////////////////////////////////////////////
+
+
+def demo():
+    from nltk.classify.util import names_demo
+
+    classifier = names_demo(NaiveBayesClassifier.train)
+    classifier.show_most_informative_features()
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/classify/positivenaivebayes.py

@@ -0,0 +1,180 @@
+# Natural Language Toolkit: Positive Naive Bayes Classifier
+#
+# Copyright (C) 2012 NLTK Project
+# Author: Alessandro Presta <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A variant of the Naive Bayes Classifier that performs binary classification with
+partially-labeled training sets. In other words, assume we want to build a classifier
+that assigns each example to one of two complementary classes (e.g., male names and
+female names).
+If we have a training set with labeled examples for both classes, we can use a
+standard Naive Bayes Classifier. However, consider the case when we only have labeled
+examples for one of the classes, and other, unlabeled, examples.
+Then, assuming a prior distribution on the two labels, we can use the unlabeled set
+to estimate the frequencies of the various features.
+
+Let the two possible labels be 1 and 0, and let's say we only have examples labeled 1
+and unlabeled examples. We are also given an estimate of P(1).
+
+We compute P(feature|1) exactly as in the standard case.
+
+To compute P(feature|0), we first estimate P(feature) from the unlabeled set (we are
+assuming that the unlabeled examples are drawn according to the given prior distribution)
+and then express the conditional probability as:
+
+|                  P(feature) - P(feature|1) * P(1)
+|  P(feature|0) = ----------------------------------
+|                               P(0)
+
+Example:
+
+    >>> from nltk.classify import PositiveNaiveBayesClassifier
+
+Some sentences about sports:
+
+    >>> sports_sentences = [ 'The team dominated the game',
+    ...                      'They lost the ball',
+    ...                      'The game was intense',
+    ...                      'The goalkeeper catched the ball',
+    ...                      'The other team controlled the ball' ]
+
+Mixed topics, including sports:
+
+    >>> various_sentences = [ 'The President did not comment',
+    ...                       'I lost the keys',
+    ...                       'The team won the game',
+    ...                       'Sara has two kids',
+    ...                       'The ball went off the court',
+    ...                       'They had the ball for the whole game',
+    ...                       'The show is over' ]
+
+The features of a sentence are simply the words it contains:
+
+    >>> def features(sentence):
+    ...     words = sentence.lower().split()
+    ...     return dict(('contains(%s)' % w, True) for w in words)
+
+We use the sports sentences as positive examples, the mixed ones ad unlabeled examples:
+
+    >>> positive_featuresets = map(features, sports_sentences)
+    >>> unlabeled_featuresets = map(features, various_sentences)
+    >>> classifier = PositiveNaiveBayesClassifier.train(positive_featuresets,
+    ...                                                 unlabeled_featuresets)
+
+Is the following sentence about sports?
+
+    >>> classifier.classify(features('The cat is on the table'))
+    False
+
+What about this one?
+
+    >>> classifier.classify(features('My team lost the game'))
+    True
+"""
+
+from collections import defaultdict
+
+from nltk.classify.naivebayes import NaiveBayesClassifier
+from nltk.probability import DictionaryProbDist, ELEProbDist, FreqDist
+
+##//////////////////////////////////////////////////////
+##  Positive Naive Bayes Classifier
+##//////////////////////////////////////////////////////
+
+
+class PositiveNaiveBayesClassifier(NaiveBayesClassifier):
+    @staticmethod
+    def train(
+        positive_featuresets,
+        unlabeled_featuresets,
+        positive_prob_prior=0.5,
+        estimator=ELEProbDist,
+    ):
+        """
+        :param positive_featuresets: An iterable of featuresets that are known as positive
+            examples (i.e., their label is ``True``).
+
+        :param unlabeled_featuresets: An iterable of featuresets whose label is unknown.
+
+        :param positive_prob_prior: A prior estimate of the probability of the label
+            ``True`` (default 0.5).
+        """
+        positive_feature_freqdist = defaultdict(FreqDist)
+        unlabeled_feature_freqdist = defaultdict(FreqDist)
+        feature_values = defaultdict(set)
+        fnames = set()
+
+        # Count up how many times each feature value occurred in positive examples.
+        num_positive_examples = 0
+        for featureset in positive_featuresets:
+            for fname, fval in featureset.items():
+                positive_feature_freqdist[fname][fval] += 1
+                feature_values[fname].add(fval)
+                fnames.add(fname)
+            num_positive_examples += 1
+
+        # Count up how many times each feature value occurred in unlabeled examples.
+        num_unlabeled_examples = 0
+        for featureset in unlabeled_featuresets:
+            for fname, fval in featureset.items():
+                unlabeled_feature_freqdist[fname][fval] += 1
+                feature_values[fname].add(fval)
+                fnames.add(fname)
+            num_unlabeled_examples += 1
+
+        # If a feature didn't have a value given for an instance, then we assume that
+        # it gets the implicit value 'None'.
+        for fname in fnames:
+            count = positive_feature_freqdist[fname].N()
+            positive_feature_freqdist[fname][None] += num_positive_examples - count
+            feature_values[fname].add(None)
+
+        for fname in fnames:
+            count = unlabeled_feature_freqdist[fname].N()
+            unlabeled_feature_freqdist[fname][None] += num_unlabeled_examples - count
+            feature_values[fname].add(None)
+
+        negative_prob_prior = 1.0 - positive_prob_prior
+
+        # Create the P(label) distribution.
+        label_probdist = DictionaryProbDist(
+            {True: positive_prob_prior, False: negative_prob_prior}
+        )
+
+        # Create the P(fval|label, fname) distribution.
+        feature_probdist = {}
+        for fname, freqdist in positive_feature_freqdist.items():
+            probdist = estimator(freqdist, bins=len(feature_values[fname]))
+            feature_probdist[True, fname] = probdist
+
+        for fname, freqdist in unlabeled_feature_freqdist.items():
+            global_probdist = estimator(freqdist, bins=len(feature_values[fname]))
+            negative_feature_probs = {}
+            for fval in feature_values[fname]:
+                prob = (
+                    global_probdist.prob(fval)
+                    - positive_prob_prior * feature_probdist[True, fname].prob(fval)
+                ) / negative_prob_prior
+                # TODO: We need to add some kind of smoothing here, instead of
+                # setting negative probabilities to zero and normalizing.
+                negative_feature_probs[fval] = max(prob, 0.0)
+            feature_probdist[False, fname] = DictionaryProbDist(
+                negative_feature_probs, normalize=True
+            )
+
+        return PositiveNaiveBayesClassifier(label_probdist, feature_probdist)
+
+
+##//////////////////////////////////////////////////////
+##  Demo
+##//////////////////////////////////////////////////////
+
+
+def demo():
+    from nltk.classify.util import partial_names_demo
+
+    classifier = partial_names_demo(PositiveNaiveBayesClassifier.train)
+    classifier.show_most_informative_features()

env-llmeval/lib/python3.10/site-packages/nltk/classify/rte_classify.py

@@ -0,0 +1,183 @@
+# Natural Language Toolkit: RTE Classifier
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ewan Klein <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Simple classifier for RTE corpus.
+
+It calculates the overlap in words and named entities between text and
+hypothesis, and also whether there are words / named entities in the
+hypothesis which fail to occur in the text, since this is an indicator that
+the hypothesis is more informative than (i.e not entailed by) the text.
+
+TO DO: better Named Entity classification
+TO DO: add lemmatization
+"""
+
+from nltk.classify.maxent import MaxentClassifier
+from nltk.classify.util import accuracy
+from nltk.tokenize import RegexpTokenizer
+
+
+class RTEFeatureExtractor:
+    """
+    This builds a bag of words for both the text and the hypothesis after
+    throwing away some stopwords, then calculates overlap and difference.
+    """
+
+    def __init__(self, rtepair, stop=True, use_lemmatize=False):
+        """
+        :param rtepair: a ``RTEPair`` from which features should be extracted
+        :param stop: if ``True``, stopwords are thrown away.
+        :type stop: bool
+        """
+        self.stop = stop
+        self.stopwords = {
+            "a",
+            "the",
+            "it",
+            "they",
+            "of",
+            "in",
+            "to",
+            "is",
+            "have",
+            "are",
+            "were",
+            "and",
+            "very",
+            ".",
+            ",",
+        }
+
+        self.negwords = {"no", "not", "never", "failed", "rejected", "denied"}
+        # Try to tokenize so that abbreviations, monetary amounts, email
+        # addresses, URLs are single tokens.
+        tokenizer = RegexpTokenizer(r"[\w.@:/]+|\w+|\$[\d.]+")
+
+        # Get the set of word types for text and hypothesis
+        self.text_tokens = tokenizer.tokenize(rtepair.text)
+        self.hyp_tokens = tokenizer.tokenize(rtepair.hyp)
+        self.text_words = set(self.text_tokens)
+        self.hyp_words = set(self.hyp_tokens)
+
+        if use_lemmatize:
+            self.text_words = {self._lemmatize(token) for token in self.text_tokens}
+            self.hyp_words = {self._lemmatize(token) for token in self.hyp_tokens}
+
+        if self.stop:
+            self.text_words = self.text_words - self.stopwords
+            self.hyp_words = self.hyp_words - self.stopwords
+
+        self._overlap = self.hyp_words & self.text_words
+        self._hyp_extra = self.hyp_words - self.text_words
+        self._txt_extra = self.text_words - self.hyp_words
+
+    def overlap(self, toktype, debug=False):
+        """
+        Compute the overlap between text and hypothesis.
+
+        :param toktype: distinguish Named Entities from ordinary words
+        :type toktype: 'ne' or 'word'
+        """
+        ne_overlap = {token for token in self._overlap if self._ne(token)}
+        if toktype == "ne":
+            if debug:
+                print("ne overlap", ne_overlap)
+            return ne_overlap
+        elif toktype == "word":
+            if debug:
+                print("word overlap", self._overlap - ne_overlap)
+            return self._overlap - ne_overlap
+        else:
+            raise ValueError("Type not recognized:'%s'" % toktype)
+
+    def hyp_extra(self, toktype, debug=True):
+        """
+        Compute the extraneous material in the hypothesis.
+
+        :param toktype: distinguish Named Entities from ordinary words
+        :type toktype: 'ne' or 'word'
+        """
+        ne_extra = {token for token in self._hyp_extra if self._ne(token)}
+        if toktype == "ne":
+            return ne_extra
+        elif toktype == "word":
+            return self._hyp_extra - ne_extra
+        else:
+            raise ValueError("Type not recognized: '%s'" % toktype)
+
+    @staticmethod
+    def _ne(token):
+        """
+        This just assumes that words in all caps or titles are
+        named entities.
+
+        :type token: str
+        """
+        if token.istitle() or token.isupper():
+            return True
+        return False
+
+    @staticmethod
+    def _lemmatize(word):
+        """
+        Use morphy from WordNet to find the base form of verbs.
+        """
+        from nltk.corpus import wordnet as wn
+
+        lemma = wn.morphy(word, pos=wn.VERB)
+        if lemma is not None:
+            return lemma
+        return word
+
+
+def rte_features(rtepair):
+    extractor = RTEFeatureExtractor(rtepair)
+    features = {}
+    features["alwayson"] = True
+    features["word_overlap"] = len(extractor.overlap("word"))
+    features["word_hyp_extra"] = len(extractor.hyp_extra("word"))
+    features["ne_overlap"] = len(extractor.overlap("ne"))
+    features["ne_hyp_extra"] = len(extractor.hyp_extra("ne"))
+    features["neg_txt"] = len(extractor.negwords & extractor.text_words)
+    features["neg_hyp"] = len(extractor.negwords & extractor.hyp_words)
+    return features
+
+
+def rte_featurize(rte_pairs):
+    return [(rte_features(pair), pair.value) for pair in rte_pairs]
+
+
+def rte_classifier(algorithm, sample_N=None):
+    from nltk.corpus import rte as rte_corpus
+
+    train_set = rte_corpus.pairs(["rte1_dev.xml", "rte2_dev.xml", "rte3_dev.xml"])
+    test_set = rte_corpus.pairs(["rte1_test.xml", "rte2_test.xml", "rte3_test.xml"])
+
+    if sample_N is not None:
+        train_set = train_set[:sample_N]
+        test_set = test_set[:sample_N]
+
+    featurized_train_set = rte_featurize(train_set)
+    featurized_test_set = rte_featurize(test_set)
+
+    # Train the classifier
+    print("Training classifier...")
+    if algorithm in ["megam"]:  # MEGAM based algorithms.
+        clf = MaxentClassifier.train(featurized_train_set, algorithm)
+    elif algorithm in ["GIS", "IIS"]:  # Use default GIS/IIS MaxEnt algorithm
+        clf = MaxentClassifier.train(featurized_train_set, algorithm)
+    else:
+        err_msg = str(
+            "RTEClassifier only supports these algorithms:\n "
+            "'megam', 'GIS', 'IIS'.\n"
+        )
+        raise Exception(err_msg)
+    print("Testing classifier...")
+    acc = accuracy(clf, featurized_test_set)
+    print("Accuracy: %6.4f" % acc)
+    return clf

env-llmeval/lib/python3.10/site-packages/nltk/classify/scikitlearn.py

@@ -0,0 +1,143 @@
+# Natural Language Toolkit: Interface to scikit-learn classifiers
+#
+# Author: Lars Buitinck <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+"""
+scikit-learn (https://scikit-learn.org) is a machine learning library for
+Python. It supports many classification algorithms, including SVMs,
+Naive Bayes, logistic regression (MaxEnt) and decision trees.
+
+This package implements a wrapper around scikit-learn classifiers. To use this
+wrapper, construct a scikit-learn estimator object, then use that to construct
+a SklearnClassifier. E.g., to wrap a linear SVM with default settings:
+
+>>> from sklearn.svm import LinearSVC
+>>> from nltk.classify.scikitlearn import SklearnClassifier
+>>> classif = SklearnClassifier(LinearSVC())
+
+A scikit-learn classifier may include preprocessing steps when it's wrapped
+in a Pipeline object. The following constructs and wraps a Naive Bayes text
+classifier with tf-idf weighting and chi-square feature selection to get the
+best 1000 features:
+
+>>> from sklearn.feature_extraction.text import TfidfTransformer
+>>> from sklearn.feature_selection import SelectKBest, chi2
+>>> from sklearn.naive_bayes import MultinomialNB
+>>> from sklearn.pipeline import Pipeline
+>>> pipeline = Pipeline([('tfidf', TfidfTransformer()),
+...                      ('chi2', SelectKBest(chi2, k=1000)),
+...                      ('nb', MultinomialNB())])
+>>> classif = SklearnClassifier(pipeline)
+"""
+
+from nltk.classify.api import ClassifierI
+from nltk.probability import DictionaryProbDist
+
+try:
+    from sklearn.feature_extraction import DictVectorizer
+    from sklearn.preprocessing import LabelEncoder
+except ImportError:
+    pass
+
+__all__ = ["SklearnClassifier"]
+
+
+class SklearnClassifier(ClassifierI):
+    """Wrapper for scikit-learn classifiers."""
+
+    def __init__(self, estimator, dtype=float, sparse=True):
+        """
+        :param estimator: scikit-learn classifier object.
+
+        :param dtype: data type used when building feature array.
+            scikit-learn estimators work exclusively on numeric data. The
+            default value should be fine for almost all situations.
+
+        :param sparse: Whether to use sparse matrices internally.
+            The estimator must support these; not all scikit-learn classifiers
+            do (see their respective documentation and look for "sparse
+            matrix"). The default value is True, since most NLP problems
+            involve sparse feature sets. Setting this to False may take a
+            great amount of memory.
+        :type sparse: boolean.
+        """
+        self._clf = estimator
+        self._encoder = LabelEncoder()
+        self._vectorizer = DictVectorizer(dtype=dtype, sparse=sparse)
+
+    def __repr__(self):
+        return "<SklearnClassifier(%r)>" % self._clf
+
+    def classify_many(self, featuresets):
+        """Classify a batch of samples.
+
+        :param featuresets: An iterable over featuresets, each a dict mapping
+            strings to either numbers, booleans or strings.
+        :return: The predicted class label for each input sample.
+        :rtype: list
+        """
+        X = self._vectorizer.transform(featuresets)
+        classes = self._encoder.classes_
+        return [classes[i] for i in self._clf.predict(X)]
+
+    def prob_classify_many(self, featuresets):
+        """Compute per-class probabilities for a batch of samples.
+
+        :param featuresets: An iterable over featuresets, each a dict mapping
+            strings to either numbers, booleans or strings.
+        :rtype: list of ``ProbDistI``
+        """
+        X = self._vectorizer.transform(featuresets)
+        y_proba_list = self._clf.predict_proba(X)
+        return [self._make_probdist(y_proba) for y_proba in y_proba_list]
+
+    def labels(self):
+        """The class labels used by this classifier.
+
+        :rtype: list
+        """
+        return list(self._encoder.classes_)
+
+    def train(self, labeled_featuresets):
+        """
+        Train (fit) the scikit-learn estimator.
+
+        :param labeled_featuresets: A list of ``(featureset, label)``
+            where each ``featureset`` is a dict mapping strings to either
+            numbers, booleans or strings.
+        """
+
+        X, y = list(zip(*labeled_featuresets))
+        X = self._vectorizer.fit_transform(X)
+        y = self._encoder.fit_transform(y)
+        self._clf.fit(X, y)
+
+        return self
+
+    def _make_probdist(self, y_proba):
+        classes = self._encoder.classes_
+        return DictionaryProbDist({classes[i]: p for i, p in enumerate(y_proba)})
+
+
+if __name__ == "__main__":
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.naive_bayes import BernoulliNB
+
+    from nltk.classify.util import names_demo, names_demo_features
+
+    # Bernoulli Naive Bayes is designed for binary classification. We set the
+    # binarize option to False since we know we're passing boolean features.
+    print("scikit-learn Naive Bayes:")
+    names_demo(
+        SklearnClassifier(BernoulliNB(binarize=False)).train,
+        features=names_demo_features,
+    )
+
+    # The C parameter on logistic regression (MaxEnt) controls regularization.
+    # The higher it's set, the less regularized the classifier is.
+    print("\n\nscikit-learn logistic regression:")
+    names_demo(
+        SklearnClassifier(LogisticRegression(C=1000)).train,
+        features=names_demo_features,
+    )

env-llmeval/lib/python3.10/site-packages/nltk/classify/senna.py

@@ -0,0 +1,176 @@
+# Natural Language Toolkit: Senna Interface
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Rami Al-Rfou' <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A general interface to the SENNA pipeline that supports any of the
+operations specified in SUPPORTED_OPERATIONS.
+
+Applying multiple operations at once has the speed advantage. For example,
+Senna will automatically determine POS tags if you are extracting named
+entities. Applying both of the operations will cost only the time of
+extracting the named entities.
+
+The SENNA pipeline has a fixed maximum size of the sentences that it can read.
+By default it is 1024 token/sentence. If you have larger sentences, changing
+the MAX_SENTENCE_SIZE value in SENNA_main.c should be considered and your
+system specific binary should be rebuilt. Otherwise this could introduce
+misalignment errors.
+
+The input is:
+
+- path to the directory that contains SENNA executables. If the path is incorrect,
+  Senna will automatically search for executable file specified in SENNA environment variable
+- List of the operations needed to be performed.
+- (optionally) the encoding of the input data (default:utf-8)
+
+Note: Unit tests for this module can be found in test/unit/test_senna.py
+
+>>> from nltk.classify import Senna
+>>> pipeline = Senna('/usr/share/senna-v3.0', ['pos', 'chk', 'ner'])  # doctest: +SKIP
+>>> sent = 'Dusseldorf is an international business center'.split()
+>>> [(token['word'], token['chk'], token['ner'], token['pos']) for token in pipeline.tag(sent)]  # doctest: +SKIP
+[('Dusseldorf', 'B-NP', 'B-LOC', 'NNP'), ('is', 'B-VP', 'O', 'VBZ'), ('an', 'B-NP', 'O', 'DT'),
+('international', 'I-NP', 'O', 'JJ'), ('business', 'I-NP', 'O', 'NN'), ('center', 'I-NP', 'O', 'NN')]
+"""
+
+from os import environ, path, sep
+from platform import architecture, system
+from subprocess import PIPE, Popen
+
+from nltk.tag.api import TaggerI
+
+
+class Senna(TaggerI):
+
+    SUPPORTED_OPERATIONS = ["pos", "chk", "ner"]
+
+    def __init__(self, senna_path, operations, encoding="utf-8"):
+        self._encoding = encoding
+        self._path = path.normpath(senna_path) + sep
+
+        # Verifies the existence of the executable on the self._path first
+        # senna_binary_file_1 = self.executable(self._path)
+        exe_file_1 = self.executable(self._path)
+        if not path.isfile(exe_file_1):
+            # Check for the system environment
+            if "SENNA" in environ:
+                # self._path = path.join(environ['SENNA'],'')
+                self._path = path.normpath(environ["SENNA"]) + sep
+                exe_file_2 = self.executable(self._path)
+                if not path.isfile(exe_file_2):
+                    raise LookupError(
+                        "Senna executable expected at %s or %s but not found"
+                        % (exe_file_1, exe_file_2)
+                    )
+
+        self.operations = operations
+
+    def executable(self, base_path):
+        """
+        The function that determines the system specific binary that should be
+        used in the pipeline. In case, the system is not known the default senna binary will
+        be used.
+        """
+        os_name = system()
+        if os_name == "Linux":
+            bits = architecture()[0]
+            if bits == "64bit":
+                return path.join(base_path, "senna-linux64")
+            return path.join(base_path, "senna-linux32")
+        if os_name == "Windows":
+            return path.join(base_path, "senna-win32.exe")
+        if os_name == "Darwin":
+            return path.join(base_path, "senna-osx")
+        return path.join(base_path, "senna")
+
+    def _map(self):
+        """
+        A method that calculates the order of the columns that SENNA pipeline
+        will output the tags into. This depends on the operations being ordered.
+        """
+        _map = {}
+        i = 1
+        for operation in Senna.SUPPORTED_OPERATIONS:
+            if operation in self.operations:
+                _map[operation] = i
+                i += 1
+        return _map
+
+    def tag(self, tokens):
+        """
+        Applies the specified operation(s) on a list of tokens.
+        """
+        return self.tag_sents([tokens])[0]
+
+    def tag_sents(self, sentences):
+        """
+        Applies the tag method over a list of sentences. This method will return a
+        list of dictionaries. Every dictionary will contain a word with its
+        calculated annotations/tags.
+        """
+        encoding = self._encoding
+
+        if not path.isfile(self.executable(self._path)):
+            raise LookupError(
+                "Senna executable expected at %s but not found"
+                % self.executable(self._path)
+            )
+
+        # Build the senna command to run the tagger
+        _senna_cmd = [
+            self.executable(self._path),
+            "-path",
+            self._path,
+            "-usrtokens",
+            "-iobtags",
+        ]
+        _senna_cmd.extend(["-" + op for op in self.operations])
+
+        # Serialize the actual sentences to a temporary string
+        _input = "\n".join(" ".join(x) for x in sentences) + "\n"
+        if isinstance(_input, str) and encoding:
+            _input = _input.encode(encoding)
+
+        # Run the tagger and get the output
+        p = Popen(_senna_cmd, stdin=PIPE, stdout=PIPE, stderr=PIPE)
+        (stdout, stderr) = p.communicate(input=_input)
+        senna_output = stdout
+
+        # Check the return code.
+        if p.returncode != 0:
+            raise RuntimeError("Senna command failed! Details: %s" % stderr)
+
+        if encoding:
+            senna_output = stdout.decode(encoding)
+
+        # Output the tagged sentences
+        map_ = self._map()
+        tagged_sentences = [[]]
+        sentence_index = 0
+        token_index = 0
+        for tagged_word in senna_output.strip().split("\n"):
+            if not tagged_word:
+                tagged_sentences.append([])
+                sentence_index += 1
+                token_index = 0
+                continue
+            tags = tagged_word.split("\t")
+            result = {}
+            for tag in map_:
+                result[tag] = tags[map_[tag]].strip()
+            try:
+                result["word"] = sentences[sentence_index][token_index]
+            except IndexError as e:
+                raise IndexError(
+                    "Misalignment error occurred at sentence number %d. Possible reason"
+                    " is that the sentence size exceeded the maximum size. Check the "
+                    "documentation of Senna class for more information."
+                    % sentence_index
+                ) from e
+            tagged_sentences[-1].append(result)
+            token_index += 1
+        return tagged_sentences

env-llmeval/lib/python3.10/site-packages/nltk/classify/svm.py

@@ -0,0 +1,17 @@
+# Natural Language Toolkit: SVM-based classifier
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Leon Derczynski <[email protected]>
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+"""
+nltk.classify.svm was deprecated. For classification based
+on support vector machines SVMs use nltk.classify.scikitlearn
+(or `scikit-learn <https://scikit-learn.org>`_ directly).
+"""
+
+
+class SvmClassifier:
+    def __init__(self, *args, **kwargs):
+        raise NotImplementedError(__doc__)

env-llmeval/lib/python3.10/site-packages/nltk/classify/textcat.py

@@ -0,0 +1,197 @@
+# Natural Language Toolkit: Language ID module using TextCat algorithm
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Avital Pekker <[email protected]>
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A module for language identification using the TextCat algorithm.
+An implementation of the text categorization algorithm
+presented in Cavnar, W. B. and J. M. Trenkle,
+"N-Gram-Based Text Categorization".
+
+The algorithm takes advantage of Zipf's law and uses
+n-gram frequencies to profile languages and text-yet to
+be identified-then compares using a distance measure.
+
+Language n-grams are provided by the "An Crubadan"
+project. A corpus reader was created separately to read
+those files.
+
+For details regarding the algorithm, see:
+https://www.let.rug.nl/~vannoord/TextCat/textcat.pdf
+
+For details about An Crubadan, see:
+https://borel.slu.edu/crubadan/index.html
+"""
+
+from sys import maxsize
+
+from nltk.util import trigrams
+
+# Note: this is NOT "re" you're likely used to. The regex module
+# is an alternative to the standard re module that supports
+# Unicode codepoint properties with the \p{} syntax.
+# You may have to "pip install regx"
+try:
+    import regex as re
+except ImportError:
+    re = None
+######################################################################
+##  Language identification using TextCat
+######################################################################
+
+
+class TextCat:
+
+    _corpus = None
+    fingerprints = {}
+    _START_CHAR = "<"
+    _END_CHAR = ">"
+
+    last_distances = {}
+
+    def __init__(self):
+        if not re:
+            raise OSError(
+                "classify.textcat requires the regex module that "
+                "supports unicode. Try '$ pip install regex' and "
+                "see https://pypi.python.org/pypi/regex for "
+                "further details."
+            )
+
+        from nltk.corpus import crubadan
+
+        self._corpus = crubadan
+        # Load all language ngrams into cache
+        for lang in self._corpus.langs():
+            self._corpus.lang_freq(lang)
+
+    def remove_punctuation(self, text):
+        """Get rid of punctuation except apostrophes"""
+        return re.sub(r"[^\P{P}\']+", "", text)
+
+    def profile(self, text):
+        """Create FreqDist of trigrams within text"""
+        from nltk import FreqDist, word_tokenize
+
+        clean_text = self.remove_punctuation(text)
+        tokens = word_tokenize(clean_text)
+
+        fingerprint = FreqDist()
+        for t in tokens:
+            token_trigram_tuples = trigrams(self._START_CHAR + t + self._END_CHAR)
+            token_trigrams = ["".join(tri) for tri in token_trigram_tuples]
+
+            for cur_trigram in token_trigrams:
+                if cur_trigram in fingerprint:
+                    fingerprint[cur_trigram] += 1
+                else:
+                    fingerprint[cur_trigram] = 1
+
+        return fingerprint
+
+    def calc_dist(self, lang, trigram, text_profile):
+        """Calculate the "out-of-place" measure between the
+        text and language profile for a single trigram"""
+
+        lang_fd = self._corpus.lang_freq(lang)
+        dist = 0
+
+        if trigram in lang_fd:
+            idx_lang_profile = list(lang_fd.keys()).index(trigram)
+            idx_text = list(text_profile.keys()).index(trigram)
+
+            # print(idx_lang_profile, ", ", idx_text)
+            dist = abs(idx_lang_profile - idx_text)
+        else:
+            # Arbitrary but should be larger than
+            # any possible trigram file length
+            # in terms of total lines
+            dist = maxsize
+
+        return dist
+
+    def lang_dists(self, text):
+        """Calculate the "out-of-place" measure between
+        the text and all languages"""
+
+        distances = {}
+        profile = self.profile(text)
+        # For all the languages
+        for lang in self._corpus._all_lang_freq.keys():
+            # Calculate distance metric for every trigram in
+            # input text to be identified
+            lang_dist = 0
+            for trigram in profile:
+                lang_dist += self.calc_dist(lang, trigram, profile)
+
+            distances[lang] = lang_dist
+
+        return distances
+
+    def guess_language(self, text):
+        """Find the language with the min distance
+        to the text and return its ISO 639-3 code"""
+        self.last_distances = self.lang_dists(text)
+
+        return min(self.last_distances, key=self.last_distances.get)
+        #################################################')
+
+
+def demo():
+    from nltk.corpus import udhr
+
+    langs = [
+        "Kurdish-UTF8",
+        "Abkhaz-UTF8",
+        "Farsi_Persian-UTF8",
+        "Hindi-UTF8",
+        "Hawaiian-UTF8",
+        "Russian-UTF8",
+        "Vietnamese-UTF8",
+        "Serbian_Srpski-UTF8",
+        "Esperanto-UTF8",
+    ]
+
+    friendly = {
+        "kmr": "Northern Kurdish",
+        "abk": "Abkhazian",
+        "pes": "Iranian Persian",
+        "hin": "Hindi",
+        "haw": "Hawaiian",
+        "rus": "Russian",
+        "vie": "Vietnamese",
+        "srp": "Serbian",
+        "epo": "Esperanto",
+    }
+
+    tc = TextCat()
+
+    for cur_lang in langs:
+        # Get raw data from UDHR corpus
+        raw_sentences = udhr.sents(cur_lang)
+        rows = len(raw_sentences) - 1
+        cols = list(map(len, raw_sentences))
+
+        sample = ""
+
+        # Generate a sample text of the language
+        for i in range(0, rows):
+            cur_sent = ""
+            for j in range(0, cols[i]):
+                cur_sent += " " + raw_sentences[i][j]
+
+            sample += cur_sent
+
+        # Try to detect what it is
+        print("Language snippet: " + sample[0:140] + "...")
+        guess = tc.guess_language(sample)
+        print(f"Language detection: {guess} ({friendly[guess]})")
+        print("#" * 140)
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/classify/util.py

@@ -0,0 +1,346 @@
+# Natural Language Toolkit: Classifier Utility Functions
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]> (minor additions)
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Utility functions and classes for classifiers.
+"""
+
+import math
+
+# from nltk.util import Deprecated
+import nltk.classify.util  # for accuracy & log_likelihood
+from nltk.util import LazyMap
+
+######################################################################
+# { Helper Functions
+######################################################################
+
+# alternative name possibility: 'map_featurefunc()'?
+# alternative name possibility: 'detect_features()'?
+# alternative name possibility: 'map_featuredetect()'?
+# or.. just have users use LazyMap directly?
+def apply_features(feature_func, toks, labeled=None):
+    """
+    Use the ``LazyMap`` class to construct a lazy list-like
+    object that is analogous to ``map(feature_func, toks)``.  In
+    particular, if ``labeled=False``, then the returned list-like
+    object's values are equal to::
+
+        [feature_func(tok) for tok in toks]
+
+    If ``labeled=True``, then the returned list-like object's values
+    are equal to::
+
+        [(feature_func(tok), label) for (tok, label) in toks]
+
+    The primary purpose of this function is to avoid the memory
+    overhead involved in storing all the featuresets for every token
+    in a corpus.  Instead, these featuresets are constructed lazily,
+    as-needed.  The reduction in memory overhead can be especially
+    significant when the underlying list of tokens is itself lazy (as
+    is the case with many corpus readers).
+
+    :param feature_func: The function that will be applied to each
+        token.  It should return a featureset -- i.e., a dict
+        mapping feature names to feature values.
+    :param toks: The list of tokens to which ``feature_func`` should be
+        applied.  If ``labeled=True``, then the list elements will be
+        passed directly to ``feature_func()``.  If ``labeled=False``,
+        then the list elements should be tuples ``(tok,label)``, and
+        ``tok`` will be passed to ``feature_func()``.
+    :param labeled: If true, then ``toks`` contains labeled tokens --
+        i.e., tuples of the form ``(tok, label)``.  (Default:
+        auto-detect based on types.)
+    """
+    if labeled is None:
+        labeled = toks and isinstance(toks[0], (tuple, list))
+    if labeled:
+
+        def lazy_func(labeled_token):
+            return (feature_func(labeled_token[0]), labeled_token[1])
+
+        return LazyMap(lazy_func, toks)
+    else:
+        return LazyMap(feature_func, toks)
+
+
+def attested_labels(tokens):
+    """
+    :return: A list of all labels that are attested in the given list
+        of tokens.
+    :rtype: list of (immutable)
+    :param tokens: The list of classified tokens from which to extract
+        labels.  A classified token has the form ``(token, label)``.
+    :type tokens: list
+    """
+    return tuple({label for (tok, label) in tokens})
+
+
+def log_likelihood(classifier, gold):
+    results = classifier.prob_classify_many([fs for (fs, l) in gold])
+    ll = [pdist.prob(l) for ((fs, l), pdist) in zip(gold, results)]
+    return math.log(sum(ll) / len(ll))
+
+
+def accuracy(classifier, gold):
+    results = classifier.classify_many([fs for (fs, l) in gold])
+    correct = [l == r for ((fs, l), r) in zip(gold, results)]
+    if correct:
+        return sum(correct) / len(correct)
+    else:
+        return 0
+
+
+class CutoffChecker:
+    """
+    A helper class that implements cutoff checks based on number of
+    iterations and log likelihood.
+
+    Accuracy cutoffs are also implemented, but they're almost never
+    a good idea to use.
+    """
+
+    def __init__(self, cutoffs):
+        self.cutoffs = cutoffs.copy()
+        if "min_ll" in cutoffs:
+            cutoffs["min_ll"] = -abs(cutoffs["min_ll"])
+        if "min_lldelta" in cutoffs:
+            cutoffs["min_lldelta"] = abs(cutoffs["min_lldelta"])
+        self.ll = None
+        self.acc = None
+        self.iter = 1
+
+    def check(self, classifier, train_toks):
+        cutoffs = self.cutoffs
+        self.iter += 1
+        if "max_iter" in cutoffs and self.iter >= cutoffs["max_iter"]:
+            return True  # iteration cutoff.
+
+        new_ll = nltk.classify.util.log_likelihood(classifier, train_toks)
+        if math.isnan(new_ll):
+            return True
+
+        if "min_ll" in cutoffs or "min_lldelta" in cutoffs:
+            if "min_ll" in cutoffs and new_ll >= cutoffs["min_ll"]:
+                return True  # log likelihood cutoff
+            if (
+                "min_lldelta" in cutoffs
+                and self.ll
+                and ((new_ll - self.ll) <= abs(cutoffs["min_lldelta"]))
+            ):
+                return True  # log likelihood delta cutoff
+            self.ll = new_ll
+
+        if "max_acc" in cutoffs or "min_accdelta" in cutoffs:
+            new_acc = nltk.classify.util.log_likelihood(classifier, train_toks)
+            if "max_acc" in cutoffs and new_acc >= cutoffs["max_acc"]:
+                return True  # log likelihood cutoff
+            if (
+                "min_accdelta" in cutoffs
+                and self.acc
+                and ((new_acc - self.acc) <= abs(cutoffs["min_accdelta"]))
+            ):
+                return True  # log likelihood delta cutoff
+            self.acc = new_acc
+
+            return False  # no cutoff reached.
+
+
+######################################################################
+# { Demos
+######################################################################
+
+
+def names_demo_features(name):
+    features = {}
+    features["alwayson"] = True
+    features["startswith"] = name[0].lower()
+    features["endswith"] = name[-1].lower()
+    for letter in "abcdefghijklmnopqrstuvwxyz":
+        features["count(%s)" % letter] = name.lower().count(letter)
+        features["has(%s)" % letter] = letter in name.lower()
+    return features
+
+
+def binary_names_demo_features(name):
+    features = {}
+    features["alwayson"] = True
+    features["startswith(vowel)"] = name[0].lower() in "aeiouy"
+    features["endswith(vowel)"] = name[-1].lower() in "aeiouy"
+    for letter in "abcdefghijklmnopqrstuvwxyz":
+        features["count(%s)" % letter] = name.lower().count(letter)
+        features["has(%s)" % letter] = letter in name.lower()
+        features["startswith(%s)" % letter] = letter == name[0].lower()
+        features["endswith(%s)" % letter] = letter == name[-1].lower()
+    return features
+
+
+def names_demo(trainer, features=names_demo_features):
+    import random
+
+    from nltk.corpus import names
+
+    # Construct a list of classified names, using the names corpus.
+    namelist = [(name, "male") for name in names.words("male.txt")] + [
+        (name, "female") for name in names.words("female.txt")
+    ]
+
+    # Randomly split the names into a test & train set.
+    random.seed(123456)
+    random.shuffle(namelist)
+    train = namelist[:5000]
+    test = namelist[5000:5500]
+
+    # Train up a classifier.
+    print("Training classifier...")
+    classifier = trainer([(features(n), g) for (n, g) in train])
+
+    # Run the classifier on the test data.
+    print("Testing classifier...")
+    acc = accuracy(classifier, [(features(n), g) for (n, g) in test])
+    print("Accuracy: %6.4f" % acc)
+
+    # For classifiers that can find probabilities, show the log
+    # likelihood and some sample probability distributions.
+    try:
+        test_featuresets = [features(n) for (n, g) in test]
+        pdists = classifier.prob_classify_many(test_featuresets)
+        ll = [pdist.logprob(gold) for ((name, gold), pdist) in zip(test, pdists)]
+        print("Avg. log likelihood: %6.4f" % (sum(ll) / len(test)))
+        print()
+        print("Unseen Names      P(Male)  P(Female)\n" + "-" * 40)
+        for ((name, gender), pdist) in list(zip(test, pdists))[:5]:
+            if gender == "male":
+                fmt = "  %-15s *%6.4f   %6.4f"
+            else:
+                fmt = "  %-15s  %6.4f  *%6.4f"
+            print(fmt % (name, pdist.prob("male"), pdist.prob("female")))
+    except NotImplementedError:
+        pass
+
+    # Return the classifier
+    return classifier
+
+
+def partial_names_demo(trainer, features=names_demo_features):
+    import random
+
+    from nltk.corpus import names
+
+    male_names = names.words("male.txt")
+    female_names = names.words("female.txt")
+
+    random.seed(654321)
+    random.shuffle(male_names)
+    random.shuffle(female_names)
+
+    # Create a list of male names to be used as positive-labeled examples for training
+    positive = map(features, male_names[:2000])
+
+    # Create a list of male and female names to be used as unlabeled examples
+    unlabeled = map(features, male_names[2000:2500] + female_names[:500])
+
+    # Create a test set with correctly-labeled male and female names
+    test = [(name, True) for name in male_names[2500:2750]] + [
+        (name, False) for name in female_names[500:750]
+    ]
+
+    random.shuffle(test)
+
+    # Train up a classifier.
+    print("Training classifier...")
+    classifier = trainer(positive, unlabeled)
+
+    # Run the classifier on the test data.
+    print("Testing classifier...")
+    acc = accuracy(classifier, [(features(n), m) for (n, m) in test])
+    print("Accuracy: %6.4f" % acc)
+
+    # For classifiers that can find probabilities, show the log
+    # likelihood and some sample probability distributions.
+    try:
+        test_featuresets = [features(n) for (n, m) in test]
+        pdists = classifier.prob_classify_many(test_featuresets)
+        ll = [pdist.logprob(gold) for ((name, gold), pdist) in zip(test, pdists)]
+        print("Avg. log likelihood: %6.4f" % (sum(ll) / len(test)))
+        print()
+        print("Unseen Names      P(Male)  P(Female)\n" + "-" * 40)
+        for ((name, is_male), pdist) in zip(test, pdists)[:5]:
+            if is_male == True:
+                fmt = "  %-15s *%6.4f   %6.4f"
+            else:
+                fmt = "  %-15s  %6.4f  *%6.4f"
+            print(fmt % (name, pdist.prob(True), pdist.prob(False)))
+    except NotImplementedError:
+        pass
+
+    # Return the classifier
+    return classifier
+
+
+_inst_cache = {}
+
+
+def wsd_demo(trainer, word, features, n=1000):
+    import random
+
+    from nltk.corpus import senseval
+
+    # Get the instances.
+    print("Reading data...")
+    global _inst_cache
+    if word not in _inst_cache:
+        _inst_cache[word] = [(i, i.senses[0]) for i in senseval.instances(word)]
+    instances = _inst_cache[word][:]
+    if n > len(instances):
+        n = len(instances)
+    senses = list({l for (i, l) in instances})
+    print("  Senses: " + " ".join(senses))
+
+    # Randomly split the names into a test & train set.
+    print("Splitting into test & train...")
+    random.seed(123456)
+    random.shuffle(instances)
+    train = instances[: int(0.8 * n)]
+    test = instances[int(0.8 * n) : n]
+
+    # Train up a classifier.
+    print("Training classifier...")
+    classifier = trainer([(features(i), l) for (i, l) in train])
+
+    # Run the classifier on the test data.
+    print("Testing classifier...")
+    acc = accuracy(classifier, [(features(i), l) for (i, l) in test])
+    print("Accuracy: %6.4f" % acc)
+
+    # For classifiers that can find probabilities, show the log
+    # likelihood and some sample probability distributions.
+    try:
+        test_featuresets = [features(i) for (i, n) in test]
+        pdists = classifier.prob_classify_many(test_featuresets)
+        ll = [pdist.logprob(gold) for ((name, gold), pdist) in zip(test, pdists)]
+        print("Avg. log likelihood: %6.4f" % (sum(ll) / len(test)))
+    except NotImplementedError:
+        pass
+
+    # Return the classifier
+    return classifier
+
+
+def check_megam_config():
+    """
+    Checks whether the MEGAM binary is configured.
+    """
+    try:
+        _megam_bin
+    except NameError as e:
+        err_msg = str(
+            "Please configure your megam binary first, e.g.\n"
+            ">>> nltk.config_megam('/usr/bin/local/megam')"
+        )
+        raise NameError(err_msg) from e

env-llmeval/lib/python3.10/site-packages/nltk/classify/weka.py

@@ -0,0 +1,377 @@
+# Natural Language Toolkit: Interface to Weka Classsifiers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Classifiers that make use of the external 'Weka' package.
+"""
+
+import os
+import re
+import subprocess
+import tempfile
+import time
+import zipfile
+from sys import stdin
+
+from nltk.classify.api import ClassifierI
+from nltk.internals import config_java, java
+from nltk.probability import DictionaryProbDist
+
+_weka_classpath = None
+_weka_search = [
+    ".",
+    "/usr/share/weka",
+    "/usr/local/share/weka",
+    "/usr/lib/weka",
+    "/usr/local/lib/weka",
+]
+
+
+def config_weka(classpath=None):
+    global _weka_classpath
+
+    # Make sure java's configured first.
+    config_java()
+
+    if classpath is not None:
+        _weka_classpath = classpath
+
+    if _weka_classpath is None:
+        searchpath = _weka_search
+        if "WEKAHOME" in os.environ:
+            searchpath.insert(0, os.environ["WEKAHOME"])
+
+        for path in searchpath:
+            if os.path.exists(os.path.join(path, "weka.jar")):
+                _weka_classpath = os.path.join(path, "weka.jar")
+                version = _check_weka_version(_weka_classpath)
+                if version:
+                    print(f"[Found Weka: {_weka_classpath} (version {version})]")
+                else:
+                    print("[Found Weka: %s]" % _weka_classpath)
+                _check_weka_version(_weka_classpath)
+
+    if _weka_classpath is None:
+        raise LookupError(
+            "Unable to find weka.jar!  Use config_weka() "
+            "or set the WEKAHOME environment variable. "
+            "For more information about Weka, please see "
+            "https://www.cs.waikato.ac.nz/ml/weka/"
+        )
+
+
+def _check_weka_version(jar):
+    try:
+        zf = zipfile.ZipFile(jar)
+    except (SystemExit, KeyboardInterrupt):
+        raise
+    except:
+        return None
+    try:
+        try:
+            return zf.read("weka/core/version.txt")
+        except KeyError:
+            return None
+    finally:
+        zf.close()
+
+
+class WekaClassifier(ClassifierI):
+    def __init__(self, formatter, model_filename):
+        self._formatter = formatter
+        self._model = model_filename
+
+    def prob_classify_many(self, featuresets):
+        return self._classify_many(featuresets, ["-p", "0", "-distribution"])
+
+    def classify_many(self, featuresets):
+        return self._classify_many(featuresets, ["-p", "0"])
+
+    def _classify_many(self, featuresets, options):
+        # Make sure we can find java & weka.
+        config_weka()
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            # Write the test data file.
+            test_filename = os.path.join(temp_dir, "test.arff")
+            self._formatter.write(test_filename, featuresets)
+
+            # Call weka to classify the data.
+            cmd = [
+                "weka.classifiers.bayes.NaiveBayes",
+                "-l",
+                self._model,
+                "-T",
+                test_filename,
+            ] + options
+            (stdout, stderr) = java(
+                cmd,
+                classpath=_weka_classpath,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+            )
+
+            # Check if something went wrong:
+            if stderr and not stdout:
+                if "Illegal options: -distribution" in stderr:
+                    raise ValueError(
+                        "The installed version of weka does "
+                        "not support probability distribution "
+                        "output."
+                    )
+                else:
+                    raise ValueError("Weka failed to generate output:\n%s" % stderr)
+
+            # Parse weka's output.
+            return self.parse_weka_output(stdout.decode(stdin.encoding).split("\n"))
+
+        finally:
+            for f in os.listdir(temp_dir):
+                os.remove(os.path.join(temp_dir, f))
+            os.rmdir(temp_dir)
+
+    def parse_weka_distribution(self, s):
+        probs = [float(v) for v in re.split("[*,]+", s) if v.strip()]
+        probs = dict(zip(self._formatter.labels(), probs))
+        return DictionaryProbDist(probs)
+
+    def parse_weka_output(self, lines):
+        # Strip unwanted text from stdout
+        for i, line in enumerate(lines):
+            if line.strip().startswith("inst#"):
+                lines = lines[i:]
+                break
+
+        if lines[0].split() == ["inst#", "actual", "predicted", "error", "prediction"]:
+            return [line.split()[2].split(":")[1] for line in lines[1:] if line.strip()]
+        elif lines[0].split() == [
+            "inst#",
+            "actual",
+            "predicted",
+            "error",
+            "distribution",
+        ]:
+            return [
+                self.parse_weka_distribution(line.split()[-1])
+                for line in lines[1:]
+                if line.strip()
+            ]
+
+        # is this safe:?
+        elif re.match(r"^0 \w+ [01]\.[0-9]* \?\s*$", lines[0]):
+            return [line.split()[1] for line in lines if line.strip()]
+
+        else:
+            for line in lines[:10]:
+                print(line)
+            raise ValueError(
+                "Unhandled output format -- your version "
+                "of weka may not be supported.\n"
+                "  Header: %s" % lines[0]
+            )
+
+    # [xx] full list of classifiers (some may be abstract?):
+    # ADTree, AODE, BayesNet, ComplementNaiveBayes, ConjunctiveRule,
+    # DecisionStump, DecisionTable, HyperPipes, IB1, IBk, Id3, J48,
+    # JRip, KStar, LBR, LeastMedSq, LinearRegression, LMT, Logistic,
+    # LogisticBase, M5Base, MultilayerPerceptron,
+    # MultipleClassifiersCombiner, NaiveBayes, NaiveBayesMultinomial,
+    # NaiveBayesSimple, NBTree, NNge, OneR, PaceRegression, PART,
+    # PreConstructedLinearModel, Prism, RandomForest,
+    # RandomizableClassifier, RandomTree, RBFNetwork, REPTree, Ridor,
+    # RuleNode, SimpleLinearRegression, SimpleLogistic,
+    # SingleClassifierEnhancer, SMO, SMOreg, UserClassifier, VFI,
+    # VotedPerceptron, Winnow, ZeroR
+
+    _CLASSIFIER_CLASS = {
+        "naivebayes": "weka.classifiers.bayes.NaiveBayes",
+        "C4.5": "weka.classifiers.trees.J48",
+        "log_regression": "weka.classifiers.functions.Logistic",
+        "svm": "weka.classifiers.functions.SMO",
+        "kstar": "weka.classifiers.lazy.KStar",
+        "ripper": "weka.classifiers.rules.JRip",
+    }
+
+    @classmethod
+    def train(
+        cls,
+        model_filename,
+        featuresets,
+        classifier="naivebayes",
+        options=[],
+        quiet=True,
+    ):
+        # Make sure we can find java & weka.
+        config_weka()
+
+        # Build an ARFF formatter.
+        formatter = ARFF_Formatter.from_train(featuresets)
+
+        temp_dir = tempfile.mkdtemp()
+        try:
+            # Write the training data file.
+            train_filename = os.path.join(temp_dir, "train.arff")
+            formatter.write(train_filename, featuresets)
+
+            if classifier in cls._CLASSIFIER_CLASS:
+                javaclass = cls._CLASSIFIER_CLASS[classifier]
+            elif classifier in cls._CLASSIFIER_CLASS.values():
+                javaclass = classifier
+            else:
+                raise ValueError("Unknown classifier %s" % classifier)
+
+            # Train the weka model.
+            cmd = [javaclass, "-d", model_filename, "-t", train_filename]
+            cmd += list(options)
+            if quiet:
+                stdout = subprocess.PIPE
+            else:
+                stdout = None
+            java(cmd, classpath=_weka_classpath, stdout=stdout)
+
+            # Return the new classifier.
+            return WekaClassifier(formatter, model_filename)
+
+        finally:
+            for f in os.listdir(temp_dir):
+                os.remove(os.path.join(temp_dir, f))
+            os.rmdir(temp_dir)
+
+
+class ARFF_Formatter:
+    """
+    Converts featuresets and labeled featuresets to ARFF-formatted
+    strings, appropriate for input into Weka.
+
+    Features and classes can be specified manually in the constructor, or may
+    be determined from data using ``from_train``.
+    """
+
+    def __init__(self, labels, features):
+        """
+        :param labels: A list of all class labels that can be generated.
+        :param features: A list of feature specifications, where
+            each feature specification is a tuple (fname, ftype);
+            and ftype is an ARFF type string such as NUMERIC or
+            STRING.
+        """
+        self._labels = labels
+        self._features = features
+
+    def format(self, tokens):
+        """Returns a string representation of ARFF output for the given data."""
+        return self.header_section() + self.data_section(tokens)
+
+    def labels(self):
+        """Returns the list of classes."""
+        return list(self._labels)
+
+    def write(self, outfile, tokens):
+        """Writes ARFF data to a file for the given data."""
+        if not hasattr(outfile, "write"):
+            outfile = open(outfile, "w")
+        outfile.write(self.format(tokens))
+        outfile.close()
+
+    @staticmethod
+    def from_train(tokens):
+        """
+        Constructs an ARFF_Formatter instance with class labels and feature
+        types determined from the given data. Handles boolean, numeric and
+        string (note: not nominal) types.
+        """
+        # Find the set of all attested labels.
+        labels = {label for (tok, label) in tokens}
+
+        # Determine the types of all features.
+        features = {}
+        for tok, label in tokens:
+            for (fname, fval) in tok.items():
+                if issubclass(type(fval), bool):
+                    ftype = "{True, False}"
+                elif issubclass(type(fval), (int, float, bool)):
+                    ftype = "NUMERIC"
+                elif issubclass(type(fval), str):
+                    ftype = "STRING"
+                elif fval is None:
+                    continue  # can't tell the type.
+                else:
+                    raise ValueError("Unsupported value type %r" % ftype)
+
+                if features.get(fname, ftype) != ftype:
+                    raise ValueError("Inconsistent type for %s" % fname)
+                features[fname] = ftype
+        features = sorted(features.items())
+
+        return ARFF_Formatter(labels, features)
+
+    def header_section(self):
+        """Returns an ARFF header as a string."""
+        # Header comment.
+        s = (
+            "% Weka ARFF file\n"
+            + "% Generated automatically by NLTK\n"
+            + "%% %s\n\n" % time.ctime()
+        )
+
+        # Relation name
+        s += "@RELATION rel\n\n"
+
+        # Input attribute specifications
+        for fname, ftype in self._features:
+            s += "@ATTRIBUTE %-30r %s\n" % (fname, ftype)
+
+        # Label attribute specification
+        s += "@ATTRIBUTE %-30r {%s}\n" % ("-label-", ",".join(self._labels))
+
+        return s
+
+    def data_section(self, tokens, labeled=None):
+        """
+        Returns the ARFF data section for the given data.
+
+        :param tokens: a list of featuresets (dicts) or labelled featuresets
+            which are tuples (featureset, label).
+        :param labeled: Indicates whether the given tokens are labeled
+            or not.  If None, then the tokens will be assumed to be
+            labeled if the first token's value is a tuple or list.
+        """
+        # Check if the tokens are labeled or unlabeled.  If unlabeled,
+        # then use 'None'
+        if labeled is None:
+            labeled = tokens and isinstance(tokens[0], (tuple, list))
+        if not labeled:
+            tokens = [(tok, None) for tok in tokens]
+
+        # Data section
+        s = "\n@DATA\n"
+        for (tok, label) in tokens:
+            for fname, ftype in self._features:
+                s += "%s," % self._fmt_arff_val(tok.get(fname))
+            s += "%s\n" % self._fmt_arff_val(label)
+
+        return s
+
+    def _fmt_arff_val(self, fval):
+        if fval is None:
+            return "?"
+        elif isinstance(fval, (bool, int)):
+            return "%s" % fval
+        elif isinstance(fval, float):
+            return "%r" % fval
+        else:
+            return "%r" % fval
+
+
+if __name__ == "__main__":
+    from nltk.classify.util import binary_names_demo_features, names_demo
+
+    def make_classifier(featuresets):
+        return WekaClassifier.train("/tmp/name.model", featuresets, "C4.5")
+
+    classifier = names_demo(make_classifier, binary_names_demo_features)

env-llmeval/lib/python3.10/site-packages/nltk/draw/__init__.py

@@ -0,0 +1,27 @@
+# Natural Language Toolkit: graphical representations package
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+# Import Tkinter-based modules if Tkinter is installed
+try:
+    import tkinter
+except ImportError:
+    import warnings
+
+    warnings.warn("nltk.draw package not loaded (please install Tkinter library).")
+else:
+    from nltk.draw.cfg import ProductionList, CFGEditor, CFGDemo
+    from nltk.draw.tree import (
+        TreeSegmentWidget,
+        tree_to_treesegment,
+        TreeWidget,
+        TreeView,
+        draw_trees,
+    )
+    from nltk.draw.table import Table
+
+from nltk.draw.dispersion import dispersion_plot

env-llmeval/lib/python3.10/site-packages/nltk/draw/cfg.py

@@ -0,0 +1,859 @@
+# Natural Language Toolkit: CFG visualization
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Visualization tools for CFGs.
+"""
+
+# Idea for a nice demo:
+#   - 3 panes: grammar, treelet, working area
+#     - grammar is a list of productions
+#     - when you select a production, the treelet that it licenses appears
+#       in the treelet area
+#     - the working area has the text on the bottom, and S at top.  When
+#       you select a production, it shows (ghosted) the locations where
+#       that production's treelet could be attached to either the text
+#       or the tree rooted at S.
+#     - the user can drag the treelet onto one of those (or click on them?)
+#     - the user can delete pieces of the tree from the working area
+#       (right click?)
+#     - connecting top to bottom? drag one NP onto another?
+#
+# +-------------------------------------------------------------+
+# | S -> NP VP   |                 S                            |
+# |[NP -> Det N ]|                / \                           |
+# |     ...      |              NP  VP                          |
+# | N -> 'dog'   |                                              |
+# | N -> 'cat'   |                                              |
+# |     ...      |                                              |
+# +--------------+                                              |
+# |      NP      |                      Det     N               |
+# |     /  \     |                       |      |               |
+# |   Det   N    |  the    cat    saw   the    dog              |
+# |              |                                              |
+# +--------------+----------------------------------------------+
+#
+# Operations:
+#   - connect a new treelet -- drag or click shadow
+#   - delete a treelet -- right click
+#     - if only connected to top, delete everything below
+#     - if only connected to bottom, delete everything above
+#   - connect top & bottom -- drag a leaf to a root or a root to a leaf
+#   - disconnect top & bottom -- right click
+#     - if connected to top & bottom, then disconnect
+
+import re
+from tkinter import (
+    Button,
+    Canvas,
+    Entry,
+    Frame,
+    IntVar,
+    Label,
+    Scrollbar,
+    Text,
+    Tk,
+    Toplevel,
+)
+
+from nltk.draw.tree import TreeSegmentWidget, tree_to_treesegment
+from nltk.draw.util import (
+    CanvasFrame,
+    ColorizedList,
+    ShowText,
+    SymbolWidget,
+    TextWidget,
+)
+from nltk.grammar import CFG, Nonterminal, _read_cfg_production, nonterminals
+from nltk.tree import Tree
+
+######################################################################
+# Production List
+######################################################################
+
+
+class ProductionList(ColorizedList):
+    ARROW = SymbolWidget.SYMBOLS["rightarrow"]
+
+    def _init_colortags(self, textwidget, options):
+        textwidget.tag_config("terminal", foreground="#006000")
+        textwidget.tag_config("arrow", font="symbol", underline="0")
+        textwidget.tag_config(
+            "nonterminal", foreground="blue", font=("helvetica", -12, "bold")
+        )
+
+    def _item_repr(self, item):
+        contents = []
+        contents.append(("%s\t" % item.lhs(), "nonterminal"))
+        contents.append((self.ARROW, "arrow"))
+        for elt in item.rhs():
+            if isinstance(elt, Nonterminal):
+                contents.append((" %s" % elt.symbol(), "nonterminal"))
+            else:
+                contents.append((" %r" % elt, "terminal"))
+        return contents
+
+
+######################################################################
+# CFG Editor
+######################################################################
+
+_CFGEditor_HELP = """
+
+The CFG Editor can be used to create or modify context free grammars.
+A context free grammar consists of a start symbol and a list of
+productions.  The start symbol is specified by the text entry field in
+the upper right hand corner of the editor; and the list of productions
+are specified in the main text editing box.
+
+Every non-blank line specifies a single production.  Each production
+has the form "LHS -> RHS," where LHS is a single nonterminal, and RHS
+is a list of nonterminals and terminals.
+
+Nonterminals must be a single word, such as S or NP or NP_subj.
+Currently, nonterminals must consists of alphanumeric characters and
+underscores (_).  Nonterminals are colored blue.  If you place the
+mouse over any nonterminal, then all occurrences of that nonterminal
+will be highlighted.
+
+Terminals must be surrounded by single quotes (') or double
+quotes(\").  For example, "dog" and "New York" are terminals.
+Currently, the string within the quotes must consist of alphanumeric
+characters, underscores, and spaces.
+
+To enter a new production, go to a blank line, and type a nonterminal,
+followed by an arrow (->), followed by a sequence of terminals and
+nonterminals.  Note that "->" (dash + greater-than) is automatically
+converted to an arrow symbol.  When you move your cursor to a
+different line, your production will automatically be colorized.  If
+there are any errors, they will be highlighted in red.
+
+Note that the order of the productions is significant for some
+algorithms.  To re-order the productions, use cut and paste to move
+them.
+
+Use the buttons at the bottom of the window when you are done editing
+the CFG:
+  - Ok: apply the new CFG, and exit the editor.
+  - Apply: apply the new CFG, and do not exit the editor.
+  - Reset: revert to the original CFG, and do not exit the editor.
+  - Cancel: revert to the original CFG, and exit the editor.
+
+"""
+
+
+class CFGEditor:
+    """
+    A dialog window for creating and editing context free grammars.
+    ``CFGEditor`` imposes the following restrictions:
+
+    - All nonterminals must be strings consisting of word
+      characters.
+    - All terminals must be strings consisting of word characters
+      and space characters.
+    """
+
+    # Regular expressions used by _analyze_line.  Precompile them, so
+    # we can process the text faster.
+    ARROW = SymbolWidget.SYMBOLS["rightarrow"]
+    _LHS_RE = re.compile(r"(^\s*\w+\s*)(->|(" + ARROW + "))")
+    _ARROW_RE = re.compile(r"\s*(->|(" + ARROW + r"))\s*")
+    _PRODUCTION_RE = re.compile(
+        r"(^\s*\w+\s*)"
+        + "(->|("  # LHS
+        + ARROW
+        + r"))\s*"
+        + r"((\w+|'[\w ]*'|\"[\w ]*\"|\|)\s*)*$"  # arrow
+    )  # RHS
+    _TOKEN_RE = re.compile("\\w+|->|'[\\w ]+'|\"[\\w ]+\"|(" + ARROW + ")")
+    _BOLD = ("helvetica", -12, "bold")
+
+    def __init__(self, parent, cfg=None, set_cfg_callback=None):
+        self._parent = parent
+        if cfg is not None:
+            self._cfg = cfg
+        else:
+            self._cfg = CFG(Nonterminal("S"), [])
+        self._set_cfg_callback = set_cfg_callback
+
+        self._highlight_matching_nonterminals = 1
+
+        # Create the top-level window.
+        self._top = Toplevel(parent)
+        self._init_bindings()
+
+        self._init_startframe()
+        self._startframe.pack(side="top", fill="x", expand=0)
+        self._init_prodframe()
+        self._prodframe.pack(side="top", fill="both", expand=1)
+        self._init_buttons()
+        self._buttonframe.pack(side="bottom", fill="x", expand=0)
+
+        self._textwidget.focus()
+
+    def _init_startframe(self):
+        frame = self._startframe = Frame(self._top)
+        self._start = Entry(frame)
+        self._start.pack(side="right")
+        Label(frame, text="Start Symbol:").pack(side="right")
+        Label(frame, text="Productions:").pack(side="left")
+        self._start.insert(0, self._cfg.start().symbol())
+
+    def _init_buttons(self):
+        frame = self._buttonframe = Frame(self._top)
+        Button(frame, text="Ok", command=self._ok, underline=0, takefocus=0).pack(
+            side="left"
+        )
+        Button(frame, text="Apply", command=self._apply, underline=0, takefocus=0).pack(
+            side="left"
+        )
+        Button(frame, text="Reset", command=self._reset, underline=0, takefocus=0).pack(
+            side="left"
+        )
+        Button(
+            frame, text="Cancel", command=self._cancel, underline=0, takefocus=0
+        ).pack(side="left")
+        Button(frame, text="Help", command=self._help, underline=0, takefocus=0).pack(
+            side="right"
+        )
+
+    def _init_bindings(self):
+        self._top.title("CFG Editor")
+        self._top.bind("<Control-q>", self._cancel)
+        self._top.bind("<Alt-q>", self._cancel)
+        self._top.bind("<Control-d>", self._cancel)
+        # self._top.bind('<Control-x>', self._cancel)
+        self._top.bind("<Alt-x>", self._cancel)
+        self._top.bind("<Escape>", self._cancel)
+        # self._top.bind('<Control-c>', self._cancel)
+        self._top.bind("<Alt-c>", self._cancel)
+
+        self._top.bind("<Control-o>", self._ok)
+        self._top.bind("<Alt-o>", self._ok)
+        self._top.bind("<Control-a>", self._apply)
+        self._top.bind("<Alt-a>", self._apply)
+        self._top.bind("<Control-r>", self._reset)
+        self._top.bind("<Alt-r>", self._reset)
+        self._top.bind("<Control-h>", self._help)
+        self._top.bind("<Alt-h>", self._help)
+        self._top.bind("<F1>", self._help)
+
+    def _init_prodframe(self):
+        self._prodframe = Frame(self._top)
+
+        # Create the basic Text widget & scrollbar.
+        self._textwidget = Text(
+            self._prodframe, background="#e0e0e0", exportselection=1
+        )
+        self._textscroll = Scrollbar(self._prodframe, takefocus=0, orient="vertical")
+        self._textwidget.config(yscrollcommand=self._textscroll.set)
+        self._textscroll.config(command=self._textwidget.yview)
+        self._textscroll.pack(side="right", fill="y")
+        self._textwidget.pack(expand=1, fill="both", side="left")
+
+        # Initialize the colorization tags.  Each nonterminal gets its
+        # own tag, so they aren't listed here.
+        self._textwidget.tag_config("terminal", foreground="#006000")
+        self._textwidget.tag_config("arrow", font="symbol")
+        self._textwidget.tag_config("error", background="red")
+
+        # Keep track of what line they're on.  We use that to remember
+        # to re-analyze a line whenever they leave it.
+        self._linenum = 0
+
+        # Expand "->" to an arrow.
+        self._top.bind(">", self._replace_arrows)
+
+        # Re-colorize lines when appropriate.
+        self._top.bind("<<Paste>>", self._analyze)
+        self._top.bind("<KeyPress>", self._check_analyze)
+        self._top.bind("<ButtonPress>", self._check_analyze)
+
+        # Tab cycles focus. (why doesn't this work??)
+        def cycle(e, textwidget=self._textwidget):
+            textwidget.tk_focusNext().focus()
+
+        self._textwidget.bind("<Tab>", cycle)
+
+        prod_tuples = [(p.lhs(), [p.rhs()]) for p in self._cfg.productions()]
+        for i in range(len(prod_tuples) - 1, 0, -1):
+            if prod_tuples[i][0] == prod_tuples[i - 1][0]:
+                if () in prod_tuples[i][1]:
+                    continue
+                if () in prod_tuples[i - 1][1]:
+                    continue
+                print(prod_tuples[i - 1][1])
+                print(prod_tuples[i][1])
+                prod_tuples[i - 1][1].extend(prod_tuples[i][1])
+                del prod_tuples[i]
+
+        for lhs, rhss in prod_tuples:
+            print(lhs, rhss)
+            s = "%s ->" % lhs
+            for rhs in rhss:
+                for elt in rhs:
+                    if isinstance(elt, Nonterminal):
+                        s += " %s" % elt
+                    else:
+                        s += " %r" % elt
+                s += " |"
+            s = s[:-2] + "\n"
+            self._textwidget.insert("end", s)
+
+        self._analyze()
+
+    #         # Add the producitons to the text widget, and colorize them.
+    #         prod_by_lhs = {}
+    #         for prod in self._cfg.productions():
+    #             if len(prod.rhs()) > 0:
+    #                 prod_by_lhs.setdefault(prod.lhs(),[]).append(prod)
+    #         for (lhs, prods) in prod_by_lhs.items():
+    #             self._textwidget.insert('end', '%s ->' % lhs)
+    #             self._textwidget.insert('end', self._rhs(prods[0]))
+    #             for prod in prods[1:]:
+    #                 print '\t|'+self._rhs(prod),
+    #                 self._textwidget.insert('end', '\t|'+self._rhs(prod))
+    #             print
+    #             self._textwidget.insert('end', '\n')
+    #         for prod in self._cfg.productions():
+    #             if len(prod.rhs()) == 0:
+    #                 self._textwidget.insert('end', '%s' % prod)
+    #         self._analyze()
+
+    #     def _rhs(self, prod):
+    #         s = ''
+    #         for elt in prod.rhs():
+    #             if isinstance(elt, Nonterminal): s += ' %s' % elt.symbol()
+    #             else: s += ' %r' % elt
+    #         return s
+
+    def _clear_tags(self, linenum):
+        """
+        Remove all tags (except ``arrow`` and ``sel``) from the given
+        line of the text widget used for editing the productions.
+        """
+        start = "%d.0" % linenum
+        end = "%d.end" % linenum
+        for tag in self._textwidget.tag_names():
+            if tag not in ("arrow", "sel"):
+                self._textwidget.tag_remove(tag, start, end)
+
+    def _check_analyze(self, *e):
+        """
+        Check if we've moved to a new line.  If we have, then remove
+        all colorization from the line we moved to, and re-colorize
+        the line that we moved from.
+        """
+        linenum = int(self._textwidget.index("insert").split(".")[0])
+        if linenum != self._linenum:
+            self._clear_tags(linenum)
+            self._analyze_line(self._linenum)
+            self._linenum = linenum
+
+    def _replace_arrows(self, *e):
+        """
+        Replace any ``'->'`` text strings with arrows (char \\256, in
+        symbol font).  This searches the whole buffer, but is fast
+        enough to be done anytime they press '>'.
+        """
+        arrow = "1.0"
+        while True:
+            arrow = self._textwidget.search("->", arrow, "end+1char")
+            if arrow == "":
+                break
+            self._textwidget.delete(arrow, arrow + "+2char")
+            self._textwidget.insert(arrow, self.ARROW, "arrow")
+            self._textwidget.insert(arrow, "\t")
+
+        arrow = "1.0"
+        while True:
+            arrow = self._textwidget.search(self.ARROW, arrow + "+1char", "end+1char")
+            if arrow == "":
+                break
+            self._textwidget.tag_add("arrow", arrow, arrow + "+1char")
+
+    def _analyze_token(self, match, linenum):
+        """
+        Given a line number and a regexp match for a token on that
+        line, colorize the token.  Note that the regexp match gives us
+        the token's text, start index (on the line), and end index (on
+        the line).
+        """
+        # What type of token is it?
+        if match.group()[0] in "'\"":
+            tag = "terminal"
+        elif match.group() in ("->", self.ARROW):
+            tag = "arrow"
+        else:
+            # If it's a nonterminal, then set up new bindings, so we
+            # can highlight all instances of that nonterminal when we
+            # put the mouse over it.
+            tag = "nonterminal_" + match.group()
+            if tag not in self._textwidget.tag_names():
+                self._init_nonterminal_tag(tag)
+
+        start = "%d.%d" % (linenum, match.start())
+        end = "%d.%d" % (linenum, match.end())
+        self._textwidget.tag_add(tag, start, end)
+
+    def _init_nonterminal_tag(self, tag, foreground="blue"):
+        self._textwidget.tag_config(tag, foreground=foreground, font=CFGEditor._BOLD)
+        if not self._highlight_matching_nonterminals:
+            return
+
+        def enter(e, textwidget=self._textwidget, tag=tag):
+            textwidget.tag_config(tag, background="#80ff80")
+
+        def leave(e, textwidget=self._textwidget, tag=tag):
+            textwidget.tag_config(tag, background="")
+
+        self._textwidget.tag_bind(tag, "<Enter>", enter)
+        self._textwidget.tag_bind(tag, "<Leave>", leave)
+
+    def _analyze_line(self, linenum):
+        """
+        Colorize a given line.
+        """
+        # Get rid of any tags that were previously on the line.
+        self._clear_tags(linenum)
+
+        # Get the line line's text string.
+        line = self._textwidget.get(repr(linenum) + ".0", repr(linenum) + ".end")
+
+        # If it's a valid production, then colorize each token.
+        if CFGEditor._PRODUCTION_RE.match(line):
+            # It's valid; Use _TOKEN_RE to tokenize the production,
+            # and call analyze_token on each token.
+            def analyze_token(match, self=self, linenum=linenum):
+                self._analyze_token(match, linenum)
+                return ""
+
+            CFGEditor._TOKEN_RE.sub(analyze_token, line)
+        elif line.strip() != "":
+            # It's invalid; show the user where the error is.
+            self._mark_error(linenum, line)
+
+    def _mark_error(self, linenum, line):
+        """
+        Mark the location of an error in a line.
+        """
+        arrowmatch = CFGEditor._ARROW_RE.search(line)
+        if not arrowmatch:
+            # If there's no arrow at all, highlight the whole line.
+            start = "%d.0" % linenum
+            end = "%d.end" % linenum
+        elif not CFGEditor._LHS_RE.match(line):
+            # Otherwise, if the LHS is bad, highlight it.
+            start = "%d.0" % linenum
+            end = "%d.%d" % (linenum, arrowmatch.start())
+        else:
+            # Otherwise, highlight the RHS.
+            start = "%d.%d" % (linenum, arrowmatch.end())
+            end = "%d.end" % linenum
+
+        # If we're highlighting 0 chars, highlight the whole line.
+        if self._textwidget.compare(start, "==", end):
+            start = "%d.0" % linenum
+            end = "%d.end" % linenum
+        self._textwidget.tag_add("error", start, end)
+
+    def _analyze(self, *e):
+        """
+        Replace ``->`` with arrows, and colorize the entire buffer.
+        """
+        self._replace_arrows()
+        numlines = int(self._textwidget.index("end").split(".")[0])
+        for linenum in range(1, numlines + 1):  # line numbers start at 1.
+            self._analyze_line(linenum)
+
+    def _parse_productions(self):
+        """
+        Parse the current contents of the textwidget buffer, to create
+        a list of productions.
+        """
+        productions = []
+
+        # Get the text, normalize it, and split it into lines.
+        text = self._textwidget.get("1.0", "end")
+        text = re.sub(self.ARROW, "->", text)
+        text = re.sub("\t", " ", text)
+        lines = text.split("\n")
+
+        # Convert each line to a CFG production
+        for line in lines:
+            line = line.strip()
+            if line == "":
+                continue
+            productions += _read_cfg_production(line)
+            # if line.strip() == '': continue
+            # if not CFGEditor._PRODUCTION_RE.match(line):
+            #    raise ValueError('Bad production string %r' % line)
+            #
+            # (lhs_str, rhs_str) = line.split('->')
+            # lhs = Nonterminal(lhs_str.strip())
+            # rhs = []
+            # def parse_token(match, rhs=rhs):
+            #    token = match.group()
+            #    if token[0] in "'\"": rhs.append(token[1:-1])
+            #    else: rhs.append(Nonterminal(token))
+            #    return ''
+            # CFGEditor._TOKEN_RE.sub(parse_token, rhs_str)
+            #
+            # productions.append(Production(lhs, *rhs))
+
+        return productions
+
+    def _destroy(self, *e):
+        if self._top is None:
+            return
+        self._top.destroy()
+        self._top = None
+
+    def _ok(self, *e):
+        self._apply()
+        self._destroy()
+
+    def _apply(self, *e):
+        productions = self._parse_productions()
+        start = Nonterminal(self._start.get())
+        cfg = CFG(start, productions)
+        if self._set_cfg_callback is not None:
+            self._set_cfg_callback(cfg)
+
+    def _reset(self, *e):
+        self._textwidget.delete("1.0", "end")
+        for production in self._cfg.productions():
+            self._textwidget.insert("end", "%s\n" % production)
+        self._analyze()
+        if self._set_cfg_callback is not None:
+            self._set_cfg_callback(self._cfg)
+
+    def _cancel(self, *e):
+        try:
+            self._reset()
+        except:
+            pass
+        self._destroy()
+
+    def _help(self, *e):
+        # The default font's not very legible; try using 'fixed' instead.
+        try:
+            ShowText(
+                self._parent,
+                "Help: Chart Parser Demo",
+                (_CFGEditor_HELP).strip(),
+                width=75,
+                font="fixed",
+            )
+        except:
+            ShowText(
+                self._parent,
+                "Help: Chart Parser Demo",
+                (_CFGEditor_HELP).strip(),
+                width=75,
+            )
+
+
+######################################################################
+# New Demo (built tree based on cfg)
+######################################################################
+
+
+class CFGDemo:
+    def __init__(self, grammar, text):
+        self._grammar = grammar
+        self._text = text
+
+        # Set up the main window.
+        self._top = Tk()
+        self._top.title("Context Free Grammar Demo")
+
+        # Base font size
+        self._size = IntVar(self._top)
+        self._size.set(12)  # = medium
+
+        # Set up the key bindings
+        self._init_bindings(self._top)
+
+        # Create the basic frames
+        frame1 = Frame(self._top)
+        frame1.pack(side="left", fill="y", expand=0)
+        self._init_menubar(self._top)
+        self._init_buttons(self._top)
+        self._init_grammar(frame1)
+        self._init_treelet(frame1)
+        self._init_workspace(self._top)
+
+    # //////////////////////////////////////////////////
+    # Initialization
+    # //////////////////////////////////////////////////
+
+    def _init_bindings(self, top):
+        top.bind("<Control-q>", self.destroy)
+
+    def _init_menubar(self, parent):
+        pass
+
+    def _init_buttons(self, parent):
+        pass
+
+    def _init_grammar(self, parent):
+        self._prodlist = ProductionList(parent, self._grammar, width=20)
+        self._prodlist.pack(side="top", fill="both", expand=1)
+        self._prodlist.focus()
+        self._prodlist.add_callback("select", self._selectprod_cb)
+        self._prodlist.add_callback("move", self._selectprod_cb)
+
+    def _init_treelet(self, parent):
+        self._treelet_canvas = Canvas(parent, background="white")
+        self._treelet_canvas.pack(side="bottom", fill="x")
+        self._treelet = None
+
+    def _init_workspace(self, parent):
+        self._workspace = CanvasFrame(parent, background="white")
+        self._workspace.pack(side="right", fill="both", expand=1)
+        self._tree = None
+        self.reset_workspace()
+
+    # //////////////////////////////////////////////////
+    # Workspace
+    # //////////////////////////////////////////////////
+
+    def reset_workspace(self):
+        c = self._workspace.canvas()
+        fontsize = int(self._size.get())
+        node_font = ("helvetica", -(fontsize + 4), "bold")
+        leaf_font = ("helvetica", -(fontsize + 2))
+
+        # Remove the old tree
+        if self._tree is not None:
+            self._workspace.remove_widget(self._tree)
+
+        # The root of the tree.
+        start = self._grammar.start().symbol()
+        rootnode = TextWidget(c, start, font=node_font, draggable=1)
+
+        # The leaves of the tree.
+        leaves = []
+        for word in self._text:
+            leaves.append(TextWidget(c, word, font=leaf_font, draggable=1))
+
+        # Put it all together into one tree
+        self._tree = TreeSegmentWidget(c, rootnode, leaves, color="white")
+
+        # Add it to the workspace.
+        self._workspace.add_widget(self._tree)
+
+        # Move the leaves to the bottom of the workspace.
+        for leaf in leaves:
+            leaf.move(0, 100)
+
+        # self._nodes = {start:1}
+        # self._leaves = dict([(l,1) for l in leaves])
+
+    def workspace_markprod(self, production):
+        pass
+
+    def _markproduction(self, prod, tree=None):
+        if tree is None:
+            tree = self._tree
+        for i in range(len(tree.subtrees()) - len(prod.rhs())):
+            if tree["color", i] == "white":
+                self._markproduction  # FIXME: Is this necessary at all?
+
+            for j, node in enumerate(prod.rhs()):
+                widget = tree.subtrees()[i + j]
+                if (
+                    isinstance(node, Nonterminal)
+                    and isinstance(widget, TreeSegmentWidget)
+                    and node.symbol == widget.label().text()
+                ):
+                    pass  # matching nonterminal
+                elif (
+                    isinstance(node, str)
+                    and isinstance(widget, TextWidget)
+                    and node == widget.text()
+                ):
+                    pass  # matching nonterminal
+                else:
+                    break
+            else:
+                # Everything matched!
+                print("MATCH AT", i)
+
+    # //////////////////////////////////////////////////
+    # Grammar
+    # //////////////////////////////////////////////////
+
+    def _selectprod_cb(self, production):
+        canvas = self._treelet_canvas
+
+        self._prodlist.highlight(production)
+        if self._treelet is not None:
+            self._treelet.destroy()
+
+        # Convert the production to a tree.
+        rhs = production.rhs()
+        for (i, elt) in enumerate(rhs):
+            if isinstance(elt, Nonterminal):
+                elt = Tree(elt)
+        tree = Tree(production.lhs().symbol(), *rhs)
+
+        # Draw the tree in the treelet area.
+        fontsize = int(self._size.get())
+        node_font = ("helvetica", -(fontsize + 4), "bold")
+        leaf_font = ("helvetica", -(fontsize + 2))
+        self._treelet = tree_to_treesegment(
+            canvas, tree, node_font=node_font, leaf_font=leaf_font
+        )
+        self._treelet["draggable"] = 1
+
+        # Center the treelet.
+        (x1, y1, x2, y2) = self._treelet.bbox()
+        w, h = int(canvas["width"]), int(canvas["height"])
+        self._treelet.move((w - x1 - x2) / 2, (h - y1 - y2) / 2)
+
+        # Mark the places where we can add it to the workspace.
+        self._markproduction(production)
+
+    def destroy(self, *args):
+        self._top.destroy()
+
+    def mainloop(self, *args, **kwargs):
+        self._top.mainloop(*args, **kwargs)
+
+
+def demo2():
+    from nltk import CFG, Nonterminal, Production
+
+    nonterminals = "S VP NP PP P N Name V Det"
+    (S, VP, NP, PP, P, N, Name, V, Det) = (Nonterminal(s) for s in nonterminals.split())
+    productions = (
+        # Syntactic Productions
+        Production(S, [NP, VP]),
+        Production(NP, [Det, N]),
+        Production(NP, [NP, PP]),
+        Production(VP, [VP, PP]),
+        Production(VP, [V, NP, PP]),
+        Production(VP, [V, NP]),
+        Production(PP, [P, NP]),
+        Production(PP, []),
+        Production(PP, ["up", "over", NP]),
+        # Lexical Productions
+        Production(NP, ["I"]),
+        Production(Det, ["the"]),
+        Production(Det, ["a"]),
+        Production(N, ["man"]),
+        Production(V, ["saw"]),
+        Production(P, ["in"]),
+        Production(P, ["with"]),
+        Production(N, ["park"]),
+        Production(N, ["dog"]),
+        Production(N, ["statue"]),
+        Production(Det, ["my"]),
+    )
+    grammar = CFG(S, productions)
+
+    text = "I saw a man in the park".split()
+    d = CFGDemo(grammar, text)
+    d.mainloop()
+
+
+######################################################################
+# Old Demo
+######################################################################
+
+
+def demo():
+    from nltk import CFG, Nonterminal
+
+    nonterminals = "S VP NP PP P N Name V Det"
+    (S, VP, NP, PP, P, N, Name, V, Det) = (Nonterminal(s) for s in nonterminals.split())
+
+    grammar = CFG.fromstring(
+        """
+    S -> NP VP
+    PP -> P NP
+    NP -> Det N
+    NP -> NP PP
+    VP -> V NP
+    VP -> VP PP
+    Det -> 'a'
+    Det -> 'the'
+    Det -> 'my'
+    NP -> 'I'
+    N -> 'dog'
+    N -> 'man'
+    N -> 'park'
+    N -> 'statue'
+    V -> 'saw'
+    P -> 'in'
+    P -> 'up'
+    P -> 'over'
+    P -> 'with'
+    """
+    )
+
+    def cb(grammar):
+        print(grammar)
+
+    top = Tk()
+    editor = CFGEditor(top, grammar, cb)
+    Label(top, text="\nTesting CFG Editor\n").pack()
+    Button(top, text="Quit", command=top.destroy).pack()
+    top.mainloop()
+
+
+def demo3():
+    from nltk import Production
+
+    (S, VP, NP, PP, P, N, Name, V, Det) = nonterminals(
+        "S, VP, NP, PP, P, N, Name, V, Det"
+    )
+
+    productions = (
+        # Syntactic Productions
+        Production(S, [NP, VP]),
+        Production(NP, [Det, N]),
+        Production(NP, [NP, PP]),
+        Production(VP, [VP, PP]),
+        Production(VP, [V, NP, PP]),
+        Production(VP, [V, NP]),
+        Production(PP, [P, NP]),
+        Production(PP, []),
+        Production(PP, ["up", "over", NP]),
+        # Lexical Productions
+        Production(NP, ["I"]),
+        Production(Det, ["the"]),
+        Production(Det, ["a"]),
+        Production(N, ["man"]),
+        Production(V, ["saw"]),
+        Production(P, ["in"]),
+        Production(P, ["with"]),
+        Production(N, ["park"]),
+        Production(N, ["dog"]),
+        Production(N, ["statue"]),
+        Production(Det, ["my"]),
+    )
+
+    t = Tk()
+
+    def destroy(e, t=t):
+        t.destroy()
+
+    t.bind("q", destroy)
+    p = ProductionList(t, productions)
+    p.pack(expand=1, fill="both")
+    p.add_callback("select", p.markonly)
+    p.add_callback("move", p.markonly)
+    p.focus()
+    p.mark(productions[2])
+    p.mark(productions[8])
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/draw/dispersion.py

@@ -0,0 +1,63 @@
+# Natural Language Toolkit: Dispersion Plots
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+A utility for displaying lexical dispersion.
+"""
+
+
+def dispersion_plot(text, words, ignore_case=False, title="Lexical Dispersion Plot"):
+    """
+    Generate a lexical dispersion plot.
+
+    :param text: The source text
+    :type text: list(str) or iter(str)
+    :param words: The target words
+    :type words: list of str
+    :param ignore_case: flag to set if case should be ignored when searching text
+    :type ignore_case: bool
+    :return: a matplotlib Axes object that may still be modified before plotting
+    :rtype: Axes
+    """
+
+    try:
+        import matplotlib.pyplot as plt
+    except ImportError as e:
+        raise ImportError(
+            "The plot function requires matplotlib to be installed. "
+            "See https://matplotlib.org/"
+        ) from e
+
+    word2y = {
+        word.casefold() if ignore_case else word: y
+        for y, word in enumerate(reversed(words))
+    }
+    xs, ys = [], []
+    for x, token in enumerate(text):
+        token = token.casefold() if ignore_case else token
+        y = word2y.get(token)
+        if y is not None:
+            xs.append(x)
+            ys.append(y)
+
+    _, ax = plt.subplots()
+    ax.plot(xs, ys, "|")
+    ax.set_yticks(list(range(len(words))), words, color="C0")
+    ax.set_ylim(-1, len(words))
+    ax.set_title(title)
+    ax.set_xlabel("Word Offset")
+    return ax
+
+
+if __name__ == "__main__":
+    import matplotlib.pyplot as plt
+
+    from nltk.corpus import gutenberg
+
+    words = ["Elinor", "Marianne", "Edward", "Willoughby"]
+    dispersion_plot(gutenberg.words("austen-sense.txt"), words)
+    plt.show()

env-llmeval/lib/python3.10/site-packages/nltk/draw/table.py

@@ -0,0 +1,1177 @@
+# Natural Language Toolkit: Table widget
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Tkinter widgets for displaying multi-column listboxes and tables.
+"""
+
+import operator
+from tkinter import Frame, Label, Listbox, Scrollbar, Tk
+
+######################################################################
+# Multi-Column Listbox
+######################################################################
+
+
+class MultiListbox(Frame):
+    """
+    A multi-column listbox, where the current selection applies to an
+    entire row.  Based on the MultiListbox Tkinter widget
+    recipe from the Python Cookbook (https://code.activestate.com/recipes/52266/)
+
+    For the most part, ``MultiListbox`` methods delegate to its
+    contained listboxes.  For any methods that do not have docstrings,
+    see ``Tkinter.Listbox`` for a description of what that method does.
+    """
+
+    # /////////////////////////////////////////////////////////////////
+    # Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    #: Default configuration values for the frame.
+    FRAME_CONFIG = dict(background="#888", takefocus=True, highlightthickness=1)
+
+    #: Default configurations for the column labels.
+    LABEL_CONFIG = dict(
+        borderwidth=1,
+        relief="raised",
+        font="helvetica -16 bold",
+        background="#444",
+        foreground="white",
+    )
+
+    #: Default configuration for the column listboxes.
+    LISTBOX_CONFIG = dict(
+        borderwidth=1,
+        selectborderwidth=0,
+        highlightthickness=0,
+        exportselection=False,
+        selectbackground="#888",
+        activestyle="none",
+        takefocus=False,
+    )
+
+    # /////////////////////////////////////////////////////////////////
+    # Constructor
+    # /////////////////////////////////////////////////////////////////
+
+    def __init__(self, master, columns, column_weights=None, cnf={}, **kw):
+        """
+        Construct a new multi-column listbox widget.
+
+        :param master: The widget that should contain the new
+            multi-column listbox.
+
+        :param columns: Specifies what columns should be included in
+            the new multi-column listbox.  If ``columns`` is an integer,
+            then it is the number of columns to include.  If it is
+            a list, then its length indicates the number of columns
+            to include; and each element of the list will be used as
+            a label for the corresponding column.
+
+        :param cnf, kw: Configuration parameters for this widget.
+            Use ``label_*`` to configure all labels; and ``listbox_*``
+            to configure all listboxes.  E.g.:
+                >>> root = Tk()  # doctest: +SKIP
+                >>> MultiListbox(root, ["Subject", "Sender", "Date"], label_foreground='red').pack()  # doctest: +SKIP
+        """
+        # If columns was specified as an int, convert it to a list.
+        if isinstance(columns, int):
+            columns = list(range(columns))
+            include_labels = False
+        else:
+            include_labels = True
+
+        if len(columns) == 0:
+            raise ValueError("Expected at least one column")
+
+        # Instance variables
+        self._column_names = tuple(columns)
+        self._listboxes = []
+        self._labels = []
+
+        # Pick a default value for column_weights, if none was specified.
+        if column_weights is None:
+            column_weights = [1] * len(columns)
+        elif len(column_weights) != len(columns):
+            raise ValueError("Expected one column_weight for each column")
+        self._column_weights = column_weights
+
+        # Configure our widgets.
+        Frame.__init__(self, master, **self.FRAME_CONFIG)
+        self.grid_rowconfigure(1, weight=1)
+        for i, label in enumerate(self._column_names):
+            self.grid_columnconfigure(i, weight=column_weights[i])
+
+            # Create a label for the column
+            if include_labels:
+                l = Label(self, text=label, **self.LABEL_CONFIG)
+                self._labels.append(l)
+                l.grid(column=i, row=0, sticky="news", padx=0, pady=0)
+                l.column_index = i
+
+            # Create a listbox for the column
+            lb = Listbox(self, **self.LISTBOX_CONFIG)
+            self._listboxes.append(lb)
+            lb.grid(column=i, row=1, sticky="news", padx=0, pady=0)
+            lb.column_index = i
+
+            # Clicking or dragging selects:
+            lb.bind("<Button-1>", self._select)
+            lb.bind("<B1-Motion>", self._select)
+            # Scroll wheel scrolls:
+            lb.bind("<Button-4>", lambda e: self._scroll(-1))
+            lb.bind("<Button-5>", lambda e: self._scroll(+1))
+            lb.bind("<MouseWheel>", lambda e: self._scroll(e.delta))
+            # Button 2 can be used to scan:
+            lb.bind("<Button-2>", lambda e: self.scan_mark(e.x, e.y))
+            lb.bind("<B2-Motion>", lambda e: self.scan_dragto(e.x, e.y))
+            # Dragging outside the window has no effect (disable
+            # the default listbox behavior, which scrolls):
+            lb.bind("<B1-Leave>", lambda e: "break")
+            # Columns can be resized by dragging them:
+            lb.bind("<Button-1>", self._resize_column)
+
+        # Columns can be resized by dragging them.  (This binding is
+        # used if they click on the grid between columns:)
+        self.bind("<Button-1>", self._resize_column)
+
+        # Set up key bindings for the widget:
+        self.bind("<Up>", lambda e: self.select(delta=-1))
+        self.bind("<Down>", lambda e: self.select(delta=1))
+        self.bind("<Prior>", lambda e: self.select(delta=-self._pagesize()))
+        self.bind("<Next>", lambda e: self.select(delta=self._pagesize()))
+
+        # Configuration customizations
+        self.configure(cnf, **kw)
+
+    # /////////////////////////////////////////////////////////////////
+    # Column Resizing
+    # /////////////////////////////////////////////////////////////////
+
+    def _resize_column(self, event):
+        """
+        Callback used to resize a column of the table.  Return ``True``
+        if the column is actually getting resized (if the user clicked
+        on the far left or far right 5 pixels of a label); and
+        ``False`` otherwies.
+        """
+        # If we're already waiting for a button release, then ignore
+        # the new button press.
+        if event.widget.bind("<ButtonRelease>"):
+            return False
+
+        # Decide which column (if any) to resize.
+        self._resize_column_index = None
+        if event.widget is self:
+            for i, lb in enumerate(self._listboxes):
+                if abs(event.x - (lb.winfo_x() + lb.winfo_width())) < 10:
+                    self._resize_column_index = i
+        elif event.x > (event.widget.winfo_width() - 5):
+            self._resize_column_index = event.widget.column_index
+        elif event.x < 5 and event.widget.column_index != 0:
+            self._resize_column_index = event.widget.column_index - 1
+
+        # Bind callbacks that are used to resize it.
+        if self._resize_column_index is not None:
+            event.widget.bind("<Motion>", self._resize_column_motion_cb)
+            event.widget.bind(
+                "<ButtonRelease-%d>" % event.num, self._resize_column_buttonrelease_cb
+            )
+            return True
+        else:
+            return False
+
+    def _resize_column_motion_cb(self, event):
+        lb = self._listboxes[self._resize_column_index]
+        charwidth = lb.winfo_width() / lb["width"]
+
+        x1 = event.x + event.widget.winfo_x()
+        x2 = lb.winfo_x() + lb.winfo_width()
+
+        lb["width"] = max(3, lb["width"] + (x1 - x2) // charwidth)
+
+    def _resize_column_buttonrelease_cb(self, event):
+        event.widget.unbind("<ButtonRelease-%d>" % event.num)
+        event.widget.unbind("<Motion>")
+
+    # /////////////////////////////////////////////////////////////////
+    # Properties
+    # /////////////////////////////////////////////////////////////////
+
+    @property
+    def column_names(self):
+        """
+        A tuple containing the names of the columns used by this
+        multi-column listbox.
+        """
+        return self._column_names
+
+    @property
+    def column_labels(self):
+        """
+        A tuple containing the ``Tkinter.Label`` widgets used to
+        display the label of each column.  If this multi-column
+        listbox was created without labels, then this will be an empty
+        tuple.  These widgets will all be augmented with a
+        ``column_index`` attribute, which can be used to determine
+        which column they correspond to.  This can be convenient,
+        e.g., when defining callbacks for bound events.
+        """
+        return tuple(self._labels)
+
+    @property
+    def listboxes(self):
+        """
+        A tuple containing the ``Tkinter.Listbox`` widgets used to
+        display individual columns.  These widgets will all be
+        augmented with a ``column_index`` attribute, which can be used
+        to determine which column they correspond to.  This can be
+        convenient, e.g., when defining callbacks for bound events.
+        """
+        return tuple(self._listboxes)
+
+    # /////////////////////////////////////////////////////////////////
+    # Mouse & Keyboard Callback Functions
+    # /////////////////////////////////////////////////////////////////
+
+    def _select(self, e):
+        i = e.widget.nearest(e.y)
+        self.selection_clear(0, "end")
+        self.selection_set(i)
+        self.activate(i)
+        self.focus()
+
+    def _scroll(self, delta):
+        for lb in self._listboxes:
+            lb.yview_scroll(delta, "unit")
+        return "break"
+
+    def _pagesize(self):
+        """:return: The number of rows that makes up one page"""
+        return int(self.index("@0,1000000")) - int(self.index("@0,0"))
+
+    # /////////////////////////////////////////////////////////////////
+    # Row selection
+    # /////////////////////////////////////////////////////////////////
+
+    def select(self, index=None, delta=None, see=True):
+        """
+        Set the selected row.  If ``index`` is specified, then select
+        row ``index``.  Otherwise, if ``delta`` is specified, then move
+        the current selection by ``delta`` (negative numbers for up,
+        positive numbers for down).  This will not move the selection
+        past the top or the bottom of the list.
+
+        :param see: If true, then call ``self.see()`` with the newly
+            selected index, to ensure that it is visible.
+        """
+        if (index is not None) and (delta is not None):
+            raise ValueError("specify index or delta, but not both")
+
+        # If delta was given, then calculate index.
+        if delta is not None:
+            if len(self.curselection()) == 0:
+                index = -1 + delta
+            else:
+                index = int(self.curselection()[0]) + delta
+
+        # Clear all selected rows.
+        self.selection_clear(0, "end")
+
+        # Select the specified index
+        if index is not None:
+            index = min(max(index, 0), self.size() - 1)
+            # self.activate(index)
+            self.selection_set(index)
+            if see:
+                self.see(index)
+
+    # /////////////////////////////////////////////////////////////////
+    # Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    def configure(self, cnf={}, **kw):
+        """
+        Configure this widget.  Use ``label_*`` to configure all
+        labels; and ``listbox_*`` to configure all listboxes.  E.g.:
+
+                >>> master = Tk()  # doctest: +SKIP
+                >>> mlb = MultiListbox(master, 5)  # doctest: +SKIP
+                >>> mlb.configure(label_foreground='red')  # doctest: +SKIP
+                >>> mlb.configure(listbox_foreground='red')  # doctest: +SKIP
+        """
+        cnf = dict(list(cnf.items()) + list(kw.items()))
+        for (key, val) in list(cnf.items()):
+            if key.startswith("label_") or key.startswith("label-"):
+                for label in self._labels:
+                    label.configure({key[6:]: val})
+            elif key.startswith("listbox_") or key.startswith("listbox-"):
+                for listbox in self._listboxes:
+                    listbox.configure({key[8:]: val})
+            else:
+                Frame.configure(self, {key: val})
+
+    def __setitem__(self, key, val):
+        """
+        Configure this widget.  This is equivalent to
+        ``self.configure({key,val``)}.  See ``configure()``.
+        """
+        self.configure({key: val})
+
+    def rowconfigure(self, row_index, cnf={}, **kw):
+        """
+        Configure all table cells in the given row.  Valid keyword
+        arguments are: ``background``, ``bg``, ``foreground``, ``fg``,
+        ``selectbackground``, ``selectforeground``.
+        """
+        for lb in self._listboxes:
+            lb.itemconfigure(row_index, cnf, **kw)
+
+    def columnconfigure(self, col_index, cnf={}, **kw):
+        """
+        Configure all table cells in the given column.  Valid keyword
+        arguments are: ``background``, ``bg``, ``foreground``, ``fg``,
+        ``selectbackground``, ``selectforeground``.
+        """
+        lb = self._listboxes[col_index]
+
+        cnf = dict(list(cnf.items()) + list(kw.items()))
+        for (key, val) in list(cnf.items()):
+            if key in (
+                "background",
+                "bg",
+                "foreground",
+                "fg",
+                "selectbackground",
+                "selectforeground",
+            ):
+                for i in range(lb.size()):
+                    lb.itemconfigure(i, {key: val})
+            else:
+                lb.configure({key: val})
+
+    def itemconfigure(self, row_index, col_index, cnf=None, **kw):
+        """
+        Configure the table cell at the given row and column.  Valid
+        keyword arguments are: ``background``, ``bg``, ``foreground``,
+        ``fg``, ``selectbackground``, ``selectforeground``.
+        """
+        lb = self._listboxes[col_index]
+        return lb.itemconfigure(row_index, cnf, **kw)
+
+    # /////////////////////////////////////////////////////////////////
+    # Value Access
+    # /////////////////////////////////////////////////////////////////
+
+    def insert(self, index, *rows):
+        """
+        Insert the given row or rows into the table, at the given
+        index.  Each row value should be a tuple of cell values, one
+        for each column in the row.  Index may be an integer or any of
+        the special strings (such as ``'end'``) accepted by
+        ``Tkinter.Listbox``.
+        """
+        for elt in rows:
+            if len(elt) != len(self._column_names):
+                raise ValueError(
+                    "rows should be tuples whose length "
+                    "is equal to the number of columns"
+                )
+        for (lb, elts) in zip(self._listboxes, list(zip(*rows))):
+            lb.insert(index, *elts)
+
+    def get(self, first, last=None):
+        """
+        Return the value(s) of the specified row(s).  If ``last`` is
+        not specified, then return a single row value; otherwise,
+        return a list of row values.  Each row value is a tuple of
+        cell values, one for each column in the row.
+        """
+        values = [lb.get(first, last) for lb in self._listboxes]
+        if last:
+            return [tuple(row) for row in zip(*values)]
+        else:
+            return tuple(values)
+
+    def bbox(self, row, col):
+        """
+        Return the bounding box for the given table cell, relative to
+        this widget's top-left corner.  The bounding box is a tuple
+        of integers ``(left, top, width, height)``.
+        """
+        dx, dy, _, _ = self.grid_bbox(row=0, column=col)
+        x, y, w, h = self._listboxes[col].bbox(row)
+        return int(x) + int(dx), int(y) + int(dy), int(w), int(h)
+
+    # /////////////////////////////////////////////////////////////////
+    # Hide/Show Columns
+    # /////////////////////////////////////////////////////////////////
+
+    def hide_column(self, col_index):
+        """
+        Hide the given column.  The column's state is still
+        maintained: its values will still be returned by ``get()``, and
+        you must supply its values when calling ``insert()``.  It is
+        safe to call this on a column that is already hidden.
+
+        :see: ``show_column()``
+        """
+        if self._labels:
+            self._labels[col_index].grid_forget()
+        self.listboxes[col_index].grid_forget()
+        self.grid_columnconfigure(col_index, weight=0)
+
+    def show_column(self, col_index):
+        """
+        Display a column that has been hidden using ``hide_column()``.
+        It is safe to call this on a column that is not hidden.
+        """
+        weight = self._column_weights[col_index]
+        if self._labels:
+            self._labels[col_index].grid(
+                column=col_index, row=0, sticky="news", padx=0, pady=0
+            )
+        self._listboxes[col_index].grid(
+            column=col_index, row=1, sticky="news", padx=0, pady=0
+        )
+        self.grid_columnconfigure(col_index, weight=weight)
+
+    # /////////////////////////////////////////////////////////////////
+    # Binding Methods
+    # /////////////////////////////////////////////////////////////////
+
+    def bind_to_labels(self, sequence=None, func=None, add=None):
+        """
+        Add a binding to each ``Tkinter.Label`` widget in this
+        mult-column listbox that will call ``func`` in response to the
+        event sequence.
+
+        :return: A list of the identifiers of replaced binding
+            functions (if any), allowing for their deletion (to
+            prevent a memory leak).
+        """
+        return [label.bind(sequence, func, add) for label in self.column_labels]
+
+    def bind_to_listboxes(self, sequence=None, func=None, add=None):
+        """
+        Add a binding to each ``Tkinter.Listbox`` widget in this
+        mult-column listbox that will call ``func`` in response to the
+        event sequence.
+
+        :return: A list of the identifiers of replaced binding
+            functions (if any), allowing for their deletion (to
+            prevent a memory leak).
+        """
+        for listbox in self.listboxes:
+            listbox.bind(sequence, func, add)
+
+    def bind_to_columns(self, sequence=None, func=None, add=None):
+        """
+        Add a binding to each ``Tkinter.Label`` and ``Tkinter.Listbox``
+        widget in this mult-column listbox that will call ``func`` in
+        response to the event sequence.
+
+        :return: A list of the identifiers of replaced binding
+            functions (if any), allowing for their deletion (to
+            prevent a memory leak).
+        """
+        return self.bind_to_labels(sequence, func, add) + self.bind_to_listboxes(
+            sequence, func, add
+        )
+
+    # /////////////////////////////////////////////////////////////////
+    # Simple Delegation
+    # /////////////////////////////////////////////////////////////////
+
+    # These methods delegate to the first listbox:
+    def curselection(self, *args, **kwargs):
+        return self._listboxes[0].curselection(*args, **kwargs)
+
+    def selection_includes(self, *args, **kwargs):
+        return self._listboxes[0].selection_includes(*args, **kwargs)
+
+    def itemcget(self, *args, **kwargs):
+        return self._listboxes[0].itemcget(*args, **kwargs)
+
+    def size(self, *args, **kwargs):
+        return self._listboxes[0].size(*args, **kwargs)
+
+    def index(self, *args, **kwargs):
+        return self._listboxes[0].index(*args, **kwargs)
+
+    def nearest(self, *args, **kwargs):
+        return self._listboxes[0].nearest(*args, **kwargs)
+
+    # These methods delegate to each listbox (and return None):
+    def activate(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.activate(*args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.delete(*args, **kwargs)
+
+    def scan_mark(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.scan_mark(*args, **kwargs)
+
+    def scan_dragto(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.scan_dragto(*args, **kwargs)
+
+    def see(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.see(*args, **kwargs)
+
+    def selection_anchor(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.selection_anchor(*args, **kwargs)
+
+    def selection_clear(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.selection_clear(*args, **kwargs)
+
+    def selection_set(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.selection_set(*args, **kwargs)
+
+    def yview(self, *args, **kwargs):
+        for lb in self._listboxes:
+            v = lb.yview(*args, **kwargs)
+        return v  # if called with no arguments
+
+    def yview_moveto(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.yview_moveto(*args, **kwargs)
+
+    def yview_scroll(self, *args, **kwargs):
+        for lb in self._listboxes:
+            lb.yview_scroll(*args, **kwargs)
+
+    # /////////////////////////////////////////////////////////////////
+    # Aliases
+    # /////////////////////////////////////////////////////////////////
+
+    itemconfig = itemconfigure
+    rowconfig = rowconfigure
+    columnconfig = columnconfigure
+    select_anchor = selection_anchor
+    select_clear = selection_clear
+    select_includes = selection_includes
+    select_set = selection_set
+
+    # /////////////////////////////////////////////////////////////////
+    # These listbox methods are not defined for multi-listbox
+    # /////////////////////////////////////////////////////////////////
+    # def xview(self, *what): pass
+    # def xview_moveto(self, fraction): pass
+    # def xview_scroll(self, number, what): pass
+
+
+######################################################################
+# Table
+######################################################################
+
+
+class Table:
+    """
+    A display widget for a table of values, based on a ``MultiListbox``
+    widget.  For many purposes, ``Table`` can be treated as a
+    list-of-lists.  E.g., table[i] is a list of the values for row i;
+    and table.append(row) adds a new row with the given list of
+    values.  Individual cells can be accessed using table[i,j], which
+    refers to the j-th column of the i-th row.  This can be used to
+    both read and write values from the table.  E.g.:
+
+        >>> table[i,j] = 'hello'  # doctest: +SKIP
+
+    The column (j) can be given either as an index number, or as a
+    column name.  E.g., the following prints the value in the 3rd row
+    for the 'First Name' column:
+
+        >>> print(table[3, 'First Name'])  # doctest: +SKIP
+        John
+
+    You can configure the colors for individual rows, columns, or
+    cells using ``rowconfig()``, ``columnconfig()``, and ``itemconfig()``.
+    The color configuration for each row will be preserved if the
+    table is modified; however, when new rows are added, any color
+    configurations that have been made for *columns* will not be
+    applied to the new row.
+
+    Note: Although ``Table`` acts like a widget in some ways (e.g., it
+    defines ``grid()``, ``pack()``, and ``bind()``), it is not itself a
+    widget; it just contains one.  This is because widgets need to
+    define ``__getitem__()``, ``__setitem__()``, and ``__nonzero__()`` in
+    a way that's incompatible with the fact that ``Table`` behaves as a
+    list-of-lists.
+
+    :ivar _mlb: The multi-column listbox used to display this table's data.
+    :ivar _rows: A list-of-lists used to hold the cell values of this
+        table.  Each element of _rows is a row value, i.e., a list of
+        cell values, one for each column in the row.
+    """
+
+    def __init__(
+        self,
+        master,
+        column_names,
+        rows=None,
+        column_weights=None,
+        scrollbar=True,
+        click_to_sort=True,
+        reprfunc=None,
+        cnf={},
+        **kw
+    ):
+        """
+        Construct a new Table widget.
+
+        :type master: Tkinter.Widget
+        :param master: The widget that should contain the new table.
+        :type column_names: list(str)
+        :param column_names: A list of names for the columns; these
+            names will be used to create labels for each column;
+            and can be used as an index when reading or writing
+            cell values from the table.
+        :type rows: list(list)
+        :param rows: A list of row values used to initialize the table.
+            Each row value should be a tuple of cell values, one for
+            each column in the row.
+        :type scrollbar: bool
+        :param scrollbar: If true, then create a scrollbar for the
+            new table widget.
+        :type click_to_sort: bool
+        :param click_to_sort: If true, then create bindings that will
+            sort the table's rows by a given column's values if the
+            user clicks on that colum's label.
+        :type reprfunc: function
+        :param reprfunc: If specified, then use this function to
+            convert each table cell value to a string suitable for
+            display.  ``reprfunc`` has the following signature:
+            reprfunc(row_index, col_index, cell_value) -> str
+            (Note that the column is specified by index, not by name.)
+        :param cnf, kw: Configuration parameters for this widget's
+            contained ``MultiListbox``.  See ``MultiListbox.__init__()``
+            for details.
+        """
+        self._num_columns = len(column_names)
+        self._reprfunc = reprfunc
+        self._frame = Frame(master)
+
+        self._column_name_to_index = {c: i for (i, c) in enumerate(column_names)}
+
+        # Make a copy of the rows & check that it's valid.
+        if rows is None:
+            self._rows = []
+        else:
+            self._rows = [[v for v in row] for row in rows]
+        for row in self._rows:
+            self._checkrow(row)
+
+        # Create our multi-list box.
+        self._mlb = MultiListbox(self._frame, column_names, column_weights, cnf, **kw)
+        self._mlb.pack(side="left", expand=True, fill="both")
+
+        # Optional scrollbar
+        if scrollbar:
+            sb = Scrollbar(self._frame, orient="vertical", command=self._mlb.yview)
+            self._mlb.listboxes[0]["yscrollcommand"] = sb.set
+            # for listbox in self._mlb.listboxes:
+            #    listbox['yscrollcommand'] = sb.set
+            sb.pack(side="right", fill="y")
+            self._scrollbar = sb
+
+        # Set up sorting
+        self._sortkey = None
+        if click_to_sort:
+            for i, l in enumerate(self._mlb.column_labels):
+                l.bind("<Button-1>", self._sort)
+
+        # Fill in our multi-list box.
+        self._fill_table()
+
+    # /////////////////////////////////////////////////////////////////
+    # { Widget-like Methods
+    # /////////////////////////////////////////////////////////////////
+    # These all just delegate to either our frame or our MLB.
+
+    def pack(self, *args, **kwargs):
+        """Position this table's main frame widget in its parent
+        widget.  See ``Tkinter.Frame.pack()`` for more info."""
+        self._frame.pack(*args, **kwargs)
+
+    def grid(self, *args, **kwargs):
+        """Position this table's main frame widget in its parent
+        widget.  See ``Tkinter.Frame.grid()`` for more info."""
+        self._frame.grid(*args, **kwargs)
+
+    def focus(self):
+        """Direct (keyboard) input foxus to this widget."""
+        self._mlb.focus()
+
+    def bind(self, sequence=None, func=None, add=None):
+        """Add a binding to this table's main frame that will call
+        ``func`` in response to the event sequence."""
+        self._mlb.bind(sequence, func, add)
+
+    def rowconfigure(self, row_index, cnf={}, **kw):
+        """:see: ``MultiListbox.rowconfigure()``"""
+        self._mlb.rowconfigure(row_index, cnf, **kw)
+
+    def columnconfigure(self, col_index, cnf={}, **kw):
+        """:see: ``MultiListbox.columnconfigure()``"""
+        col_index = self.column_index(col_index)
+        self._mlb.columnconfigure(col_index, cnf, **kw)
+
+    def itemconfigure(self, row_index, col_index, cnf=None, **kw):
+        """:see: ``MultiListbox.itemconfigure()``"""
+        col_index = self.column_index(col_index)
+        return self._mlb.itemconfigure(row_index, col_index, cnf, **kw)
+
+    def bind_to_labels(self, sequence=None, func=None, add=None):
+        """:see: ``MultiListbox.bind_to_labels()``"""
+        return self._mlb.bind_to_labels(sequence, func, add)
+
+    def bind_to_listboxes(self, sequence=None, func=None, add=None):
+        """:see: ``MultiListbox.bind_to_listboxes()``"""
+        return self._mlb.bind_to_listboxes(sequence, func, add)
+
+    def bind_to_columns(self, sequence=None, func=None, add=None):
+        """:see: ``MultiListbox.bind_to_columns()``"""
+        return self._mlb.bind_to_columns(sequence, func, add)
+
+    rowconfig = rowconfigure
+    columnconfig = columnconfigure
+    itemconfig = itemconfigure
+
+    # /////////////////////////////////////////////////////////////////
+    # { Table as list-of-lists
+    # /////////////////////////////////////////////////////////////////
+
+    def insert(self, row_index, rowvalue):
+        """
+        Insert a new row into the table, so that its row index will be
+        ``row_index``.  If the table contains any rows whose row index
+        is greater than or equal to ``row_index``, then they will be
+        shifted down.
+
+        :param rowvalue: A tuple of cell values, one for each column
+            in the new row.
+        """
+        self._checkrow(rowvalue)
+        self._rows.insert(row_index, rowvalue)
+        if self._reprfunc is not None:
+            rowvalue = [
+                self._reprfunc(row_index, j, v) for (j, v) in enumerate(rowvalue)
+            ]
+        self._mlb.insert(row_index, rowvalue)
+        if self._DEBUG:
+            self._check_table_vs_mlb()
+
+    def extend(self, rowvalues):
+        """
+        Add new rows at the end of the table.
+
+        :param rowvalues: A list of row values used to initialize the
+            table.  Each row value should be a tuple of cell values,
+            one for each column in the row.
+        """
+        for rowvalue in rowvalues:
+            self.append(rowvalue)
+        if self._DEBUG:
+            self._check_table_vs_mlb()
+
+    def append(self, rowvalue):
+        """
+        Add a new row to the end of the table.
+
+        :param rowvalue: A tuple of cell values, one for each column
+            in the new row.
+        """
+        self.insert(len(self._rows), rowvalue)
+        if self._DEBUG:
+            self._check_table_vs_mlb()
+
+    def clear(self):
+        """
+        Delete all rows in this table.
+        """
+        self._rows = []
+        self._mlb.delete(0, "end")
+        if self._DEBUG:
+            self._check_table_vs_mlb()
+
+    def __getitem__(self, index):
+        """
+        Return the value of a row or a cell in this table.  If
+        ``index`` is an integer, then the row value for the ``index``th
+        row.  This row value consists of a tuple of cell values, one
+        for each column in the row.  If ``index`` is a tuple of two
+        integers, ``(i,j)``, then return the value of the cell in the
+        ``i``th row and the ``j``th column.
+        """
+        if isinstance(index, slice):
+            raise ValueError("Slicing not supported")
+        elif isinstance(index, tuple) and len(index) == 2:
+            return self._rows[index[0]][self.column_index(index[1])]
+        else:
+            return tuple(self._rows[index])
+
+    def __setitem__(self, index, val):
+        """
+        Replace the value of a row or a cell in this table with
+        ``val``.
+
+        If ``index`` is an integer, then ``val`` should be a row value
+        (i.e., a tuple of cell values, one for each column).  In this
+        case, the values of the ``index``th row of the table will be
+        replaced with the values in ``val``.
+
+        If ``index`` is a tuple of integers, ``(i,j)``, then replace the
+        value of the cell in the ``i``th row and ``j``th column with
+        ``val``.
+        """
+        if isinstance(index, slice):
+            raise ValueError("Slicing not supported")
+
+        # table[i,j] = val
+        elif isinstance(index, tuple) and len(index) == 2:
+            i, j = index[0], self.column_index(index[1])
+            config_cookie = self._save_config_info([i])
+            self._rows[i][j] = val
+            if self._reprfunc is not None:
+                val = self._reprfunc(i, j, val)
+            self._mlb.listboxes[j].insert(i, val)
+            self._mlb.listboxes[j].delete(i + 1)
+            self._restore_config_info(config_cookie)
+
+        # table[i] = val
+        else:
+            config_cookie = self._save_config_info([index])
+            self._checkrow(val)
+            self._rows[index] = list(val)
+            if self._reprfunc is not None:
+                val = [self._reprfunc(index, j, v) for (j, v) in enumerate(val)]
+            self._mlb.insert(index, val)
+            self._mlb.delete(index + 1)
+            self._restore_config_info(config_cookie)
+
+    def __delitem__(self, row_index):
+        """
+        Delete the ``row_index``th row from this table.
+        """
+        if isinstance(row_index, slice):
+            raise ValueError("Slicing not supported")
+        if isinstance(row_index, tuple) and len(row_index) == 2:
+            raise ValueError("Cannot delete a single cell!")
+        del self._rows[row_index]
+        self._mlb.delete(row_index)
+        if self._DEBUG:
+            self._check_table_vs_mlb()
+
+    def __len__(self):
+        """
+        :return: the number of rows in this table.
+        """
+        return len(self._rows)
+
+    def _checkrow(self, rowvalue):
+        """
+        Helper function: check that a given row value has the correct
+        number of elements; and if not, raise an exception.
+        """
+        if len(rowvalue) != self._num_columns:
+            raise ValueError(
+                "Row %r has %d columns; expected %d"
+                % (rowvalue, len(rowvalue), self._num_columns)
+            )
+
+    # /////////////////////////////////////////////////////////////////
+    # Columns
+    # /////////////////////////////////////////////////////////////////
+
+    @property
+    def column_names(self):
+        """A list of the names of the columns in this table."""
+        return self._mlb.column_names
+
+    def column_index(self, i):
+        """
+        If ``i`` is a valid column index integer, then return it as is.
+        Otherwise, check if ``i`` is used as the name for any column;
+        if so, return that column's index.  Otherwise, raise a
+        ``KeyError`` exception.
+        """
+        if isinstance(i, int) and 0 <= i < self._num_columns:
+            return i
+        else:
+            # This raises a key error if the column is not found.
+            return self._column_name_to_index[i]
+
+    def hide_column(self, column_index):
+        """:see: ``MultiListbox.hide_column()``"""
+        self._mlb.hide_column(self.column_index(column_index))
+
+    def show_column(self, column_index):
+        """:see: ``MultiListbox.show_column()``"""
+        self._mlb.show_column(self.column_index(column_index))
+
+    # /////////////////////////////////////////////////////////////////
+    # Selection
+    # /////////////////////////////////////////////////////////////////
+
+    def selected_row(self):
+        """
+        Return the index of the currently selected row, or None if
+        no row is selected.  To get the row value itself, use
+        ``table[table.selected_row()]``.
+        """
+        sel = self._mlb.curselection()
+        if sel:
+            return int(sel[0])
+        else:
+            return None
+
+    def select(self, index=None, delta=None, see=True):
+        """:see: ``MultiListbox.select()``"""
+        self._mlb.select(index, delta, see)
+
+    # /////////////////////////////////////////////////////////////////
+    # Sorting
+    # /////////////////////////////////////////////////////////////////
+
+    def sort_by(self, column_index, order="toggle"):
+        """
+        Sort the rows in this table, using the specified column's
+        values as a sort key.
+
+        :param column_index: Specifies which column to sort, using
+            either a column index (int) or a column's label name
+            (str).
+
+        :param order: Specifies whether to sort the values in
+            ascending or descending order:
+
+              - ``'ascending'``: Sort from least to greatest.
+              - ``'descending'``: Sort from greatest to least.
+              - ``'toggle'``: If the most recent call to ``sort_by()``
+                sorted the table by the same column (``column_index``),
+                then reverse the rows; otherwise sort in ascending
+                order.
+        """
+        if order not in ("ascending", "descending", "toggle"):
+            raise ValueError(
+                'sort_by(): order should be "ascending", ' '"descending", or "toggle".'
+            )
+        column_index = self.column_index(column_index)
+        config_cookie = self._save_config_info(index_by_id=True)
+
+        # Sort the rows.
+        if order == "toggle" and column_index == self._sortkey:
+            self._rows.reverse()
+        else:
+            self._rows.sort(
+                key=operator.itemgetter(column_index), reverse=(order == "descending")
+            )
+            self._sortkey = column_index
+
+        # Redraw the table.
+        self._fill_table()
+        self._restore_config_info(config_cookie, index_by_id=True, see=True)
+        if self._DEBUG:
+            self._check_table_vs_mlb()
+
+    def _sort(self, event):
+        """Event handler for clicking on a column label -- sort by
+        that column."""
+        column_index = event.widget.column_index
+
+        # If they click on the far-left of far-right of a column's
+        # label, then resize rather than sorting.
+        if self._mlb._resize_column(event):
+            return "continue"
+
+        # Otherwise, sort.
+        else:
+            self.sort_by(column_index)
+            return "continue"
+
+    # /////////////////////////////////////////////////////////////////
+    # { Table Drawing Helpers
+    # /////////////////////////////////////////////////////////////////
+
+    def _fill_table(self, save_config=True):
+        """
+        Re-draw the table from scratch, by clearing out the table's
+        multi-column listbox; and then filling it in with values from
+        ``self._rows``.  Note that any cell-, row-, or column-specific
+        color configuration that has been done will be lost.  The
+        selection will also be lost -- i.e., no row will be selected
+        after this call completes.
+        """
+        self._mlb.delete(0, "end")
+        for i, row in enumerate(self._rows):
+            if self._reprfunc is not None:
+                row = [self._reprfunc(i, j, v) for (j, v) in enumerate(row)]
+            self._mlb.insert("end", row)
+
+    def _get_itemconfig(self, r, c):
+        return {
+            k: self._mlb.itemconfig(r, c, k)[-1]
+            for k in (
+                "foreground",
+                "selectforeground",
+                "background",
+                "selectbackground",
+            )
+        }
+
+    def _save_config_info(self, row_indices=None, index_by_id=False):
+        """
+        Return a 'cookie' containing information about which row is
+        selected, and what color configurations have been applied.
+        this information can the be re-applied to the table (after
+        making modifications) using ``_restore_config_info()``.  Color
+        configuration information will be saved for any rows in
+        ``row_indices``, or in the entire table, if
+        ``row_indices=None``.  If ``index_by_id=True``, the the cookie
+        will associate rows with their configuration information based
+        on the rows' python id.  This is useful when performing
+        operations that re-arrange the rows (e.g. ``sort``).  If
+        ``index_by_id=False``, then it is assumed that all rows will be
+        in the same order when ``_restore_config_info()`` is called.
+        """
+        # Default value for row_indices is all rows.
+        if row_indices is None:
+            row_indices = list(range(len(self._rows)))
+
+        # Look up our current selection.
+        selection = self.selected_row()
+        if index_by_id and selection is not None:
+            selection = id(self._rows[selection])
+
+        # Look up the color configuration info for each row.
+        if index_by_id:
+            config = {
+                id(self._rows[r]): [
+                    self._get_itemconfig(r, c) for c in range(self._num_columns)
+                ]
+                for r in row_indices
+            }
+        else:
+            config = {
+                r: [self._get_itemconfig(r, c) for c in range(self._num_columns)]
+                for r in row_indices
+            }
+
+        return selection, config
+
+    def _restore_config_info(self, cookie, index_by_id=False, see=False):
+        """
+        Restore selection & color configuration information that was
+        saved using ``_save_config_info``.
+        """
+        selection, config = cookie
+
+        # Clear the selection.
+        if selection is None:
+            self._mlb.selection_clear(0, "end")
+
+        # Restore selection & color config
+        if index_by_id:
+            for r, row in enumerate(self._rows):
+                if id(row) in config:
+                    for c in range(self._num_columns):
+                        self._mlb.itemconfigure(r, c, config[id(row)][c])
+                if id(row) == selection:
+                    self._mlb.select(r, see=see)
+        else:
+            if selection is not None:
+                self._mlb.select(selection, see=see)
+            for r in config:
+                for c in range(self._num_columns):
+                    self._mlb.itemconfigure(r, c, config[r][c])
+
+    # /////////////////////////////////////////////////////////////////
+    # Debugging (Invariant Checker)
+    # /////////////////////////////////////////////////////////////////
+
+    _DEBUG = False
+    """If true, then run ``_check_table_vs_mlb()`` after any operation
+       that modifies the table."""
+
+    def _check_table_vs_mlb(self):
+        """
+        Verify that the contents of the table's ``_rows`` variable match
+        the contents of its multi-listbox (``_mlb``).  This is just
+        included for debugging purposes, to make sure that the
+        list-modifying operations are working correctly.
+        """
+        for col in self._mlb.listboxes:
+            assert len(self) == col.size()
+        for row in self:
+            assert len(row) == self._num_columns
+        assert self._num_columns == len(self._mlb.column_names)
+        # assert self._column_names == self._mlb.column_names
+        for i, row in enumerate(self):
+            for j, cell in enumerate(row):
+                if self._reprfunc is not None:
+                    cell = self._reprfunc(i, j, cell)
+                assert self._mlb.get(i)[j] == cell
+
+
+######################################################################
+# Demo/Test Function
+######################################################################
+
+# update this to use new WordNet API
+def demo():
+    root = Tk()
+    root.bind("<Control-q>", lambda e: root.destroy())
+
+    table = Table(
+        root,
+        "Word Synset Hypernym Hyponym".split(),
+        column_weights=[0, 1, 1, 1],
+        reprfunc=(lambda i, j, s: "  %s" % s),
+    )
+    table.pack(expand=True, fill="both")
+
+    from nltk.corpus import brown, wordnet
+
+    for word, pos in sorted(set(brown.tagged_words()[:500])):
+        if pos[0] != "N":
+            continue
+        word = word.lower()
+        for synset in wordnet.synsets(word):
+            try:
+                hyper_def = synset.hypernyms()[0].definition()
+            except:
+                hyper_def = "*none*"
+            try:
+                hypo_def = synset.hypernyms()[0].definition()
+            except:
+                hypo_def = "*none*"
+            table.append([word, synset.definition(), hyper_def, hypo_def])
+
+    table.columnconfig("Word", background="#afa")
+    table.columnconfig("Synset", background="#efe")
+    table.columnconfig("Hypernym", background="#fee")
+    table.columnconfig("Hyponym", background="#ffe")
+    for row in range(len(table)):
+        for column in ("Hypernym", "Hyponym"):
+            if table[row, column] == "*none*":
+                table.itemconfig(
+                    row, column, foreground="#666", selectforeground="#666"
+                )
+    root.mainloop()
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/draw/tree.py

@@ -0,0 +1,1129 @@
+# Natural Language Toolkit: Graphical Representations for Trees
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Graphically display a Tree.
+"""
+
+from tkinter import IntVar, Menu, Tk
+
+from nltk.draw.util import (
+    BoxWidget,
+    CanvasFrame,
+    CanvasWidget,
+    OvalWidget,
+    ParenWidget,
+    TextWidget,
+)
+from nltk.tree import Tree
+from nltk.util import in_idle
+
+##//////////////////////////////////////////////////////
+##  Tree Segment
+##//////////////////////////////////////////////////////
+
+
+class TreeSegmentWidget(CanvasWidget):
+    """
+    A canvas widget that displays a single segment of a hierarchical
+    tree.  Each ``TreeSegmentWidget`` connects a single "node widget"
+    to a sequence of zero or more "subtree widgets".  By default, the
+    bottom of the node is connected to the top of each subtree by a
+    single line.  However, if the ``roof`` attribute is set, then a
+    single triangular "roof" will connect the node to all of its
+    children.
+
+    Attributes:
+      - ``roof``: What sort of connection to draw between the node and
+        its subtrees.  If ``roof`` is true, draw a single triangular
+        "roof" over the subtrees.  If ``roof`` is false, draw a line
+        between each subtree and the node.  Default value is false.
+      - ``xspace``: The amount of horizontal space to leave between
+        subtrees when managing this widget.  Default value is 10.
+      - ``yspace``: The amount of space to place between the node and
+        its children when managing this widget.  Default value is 15.
+      - ``color``: The color of the lines connecting the node to its
+        subtrees; and of the outline of the triangular roof.  Default
+        value is ``'#006060'``.
+      - ``fill``: The fill color for the triangular roof.  Default
+        value is ``''`` (no fill).
+      - ``width``: The width of the lines connecting the node to its
+        subtrees; and of the outline of the triangular roof.  Default
+        value is 1.
+      - ``orientation``: Determines whether the tree branches downwards
+        or rightwards.  Possible values are ``'horizontal'`` and
+        ``'vertical'``.  The default value is ``'vertical'`` (i.e.,
+        branch downwards).
+      - ``draggable``: whether the widget can be dragged by the user.
+    """
+
+    def __init__(self, canvas, label, subtrees, **attribs):
+        """
+        :type node:
+        :type subtrees: list(CanvasWidgetI)
+        """
+        self._label = label
+        self._subtrees = subtrees
+
+        # Attributes
+        self._horizontal = 0
+        self._roof = 0
+        self._xspace = 10
+        self._yspace = 15
+        self._ordered = False
+
+        # Create canvas objects.
+        self._lines = [canvas.create_line(0, 0, 0, 0, fill="#006060") for c in subtrees]
+        self._polygon = canvas.create_polygon(
+            0, 0, fill="", state="hidden", outline="#006060"
+        )
+
+        # Register child widgets (label + subtrees)
+        self._add_child_widget(label)
+        for subtree in subtrees:
+            self._add_child_widget(subtree)
+
+        # Are we currently managing?
+        self._managing = False
+
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    def __setitem__(self, attr, value):
+        canvas = self.canvas()
+        if attr == "roof":
+            self._roof = value
+            if self._roof:
+                for l in self._lines:
+                    canvas.itemconfig(l, state="hidden")
+                canvas.itemconfig(self._polygon, state="normal")
+            else:
+                for l in self._lines:
+                    canvas.itemconfig(l, state="normal")
+                canvas.itemconfig(self._polygon, state="hidden")
+        elif attr == "orientation":
+            if value == "horizontal":
+                self._horizontal = 1
+            elif value == "vertical":
+                self._horizontal = 0
+            else:
+                raise ValueError("orientation must be horizontal or vertical")
+        elif attr == "color":
+            for l in self._lines:
+                canvas.itemconfig(l, fill=value)
+            canvas.itemconfig(self._polygon, outline=value)
+        elif isinstance(attr, tuple) and attr[0] == "color":
+            # Set the color of an individual line.
+            l = self._lines[int(attr[1])]
+            canvas.itemconfig(l, fill=value)
+        elif attr == "fill":
+            canvas.itemconfig(self._polygon, fill=value)
+        elif attr == "width":
+            canvas.itemconfig(self._polygon, {attr: value})
+            for l in self._lines:
+                canvas.itemconfig(l, {attr: value})
+        elif attr in ("xspace", "yspace"):
+            if attr == "xspace":
+                self._xspace = value
+            elif attr == "yspace":
+                self._yspace = value
+            self.update(self._label)
+        elif attr == "ordered":
+            self._ordered = value
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "roof":
+            return self._roof
+        elif attr == "width":
+            return self.canvas().itemcget(self._polygon, attr)
+        elif attr == "color":
+            return self.canvas().itemcget(self._polygon, "outline")
+        elif isinstance(attr, tuple) and attr[0] == "color":
+            l = self._lines[int(attr[1])]
+            return self.canvas().itemcget(l, "fill")
+        elif attr == "xspace":
+            return self._xspace
+        elif attr == "yspace":
+            return self._yspace
+        elif attr == "orientation":
+            if self._horizontal:
+                return "horizontal"
+            else:
+                return "vertical"
+        elif attr == "ordered":
+            return self._ordered
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def label(self):
+        return self._label
+
+    def subtrees(self):
+        return self._subtrees[:]
+
+    def set_label(self, label):
+        """
+        Set the node label to ``label``.
+        """
+        self._remove_child_widget(self._label)
+        self._add_child_widget(label)
+        self._label = label
+        self.update(self._label)
+
+    def replace_child(self, oldchild, newchild):
+        """
+        Replace the child ``oldchild`` with ``newchild``.
+        """
+        index = self._subtrees.index(oldchild)
+        self._subtrees[index] = newchild
+        self._remove_child_widget(oldchild)
+        self._add_child_widget(newchild)
+        self.update(newchild)
+
+    def remove_child(self, child):
+        index = self._subtrees.index(child)
+        del self._subtrees[index]
+        self._remove_child_widget(child)
+        self.canvas().delete(self._lines.pop())
+        self.update(self._label)
+
+    def insert_child(self, index, child):
+        canvas = self.canvas()
+        self._subtrees.insert(index, child)
+        self._add_child_widget(child)
+        self._lines.append(canvas.create_line(0, 0, 0, 0, fill="#006060"))
+        self.update(self._label)
+
+    # but.. lines???
+
+    def _tags(self):
+        if self._roof:
+            return [self._polygon]
+        else:
+            return self._lines
+
+    def _subtree_top(self, child):
+        if isinstance(child, TreeSegmentWidget):
+            bbox = child.label().bbox()
+        else:
+            bbox = child.bbox()
+        if self._horizontal:
+            return (bbox[0], (bbox[1] + bbox[3]) / 2.0)
+        else:
+            return ((bbox[0] + bbox[2]) / 2.0, bbox[1])
+
+    def _node_bottom(self):
+        bbox = self._label.bbox()
+        if self._horizontal:
+            return (bbox[2], (bbox[1] + bbox[3]) / 2.0)
+        else:
+            return ((bbox[0] + bbox[2]) / 2.0, bbox[3])
+
+    def _update(self, child):
+        if len(self._subtrees) == 0:
+            return
+        if self._label.bbox() is None:
+            return  # [XX] ???
+
+        # Which lines need to be redrawn?
+        if child is self._label:
+            need_update = self._subtrees
+        else:
+            need_update = [child]
+
+        if self._ordered and not self._managing:
+            need_update = self._maintain_order(child)
+
+        # Update the polygon.
+        (nodex, nodey) = self._node_bottom()
+        (xmin, ymin, xmax, ymax) = self._subtrees[0].bbox()
+        for subtree in self._subtrees[1:]:
+            bbox = subtree.bbox()
+            xmin = min(xmin, bbox[0])
+            ymin = min(ymin, bbox[1])
+            xmax = max(xmax, bbox[2])
+            ymax = max(ymax, bbox[3])
+
+        if self._horizontal:
+            self.canvas().coords(
+                self._polygon, nodex, nodey, xmin, ymin, xmin, ymax, nodex, nodey
+            )
+        else:
+            self.canvas().coords(
+                self._polygon, nodex, nodey, xmin, ymin, xmax, ymin, nodex, nodey
+            )
+
+        # Redraw all lines that need it.
+        for subtree in need_update:
+            (nodex, nodey) = self._node_bottom()
+            line = self._lines[self._subtrees.index(subtree)]
+            (subtreex, subtreey) = self._subtree_top(subtree)
+            self.canvas().coords(line, nodex, nodey, subtreex, subtreey)
+
+    def _maintain_order(self, child):
+        if self._horizontal:
+            return self._maintain_order_horizontal(child)
+        else:
+            return self._maintain_order_vertical(child)
+
+    def _maintain_order_vertical(self, child):
+        (left, top, right, bot) = child.bbox()
+
+        if child is self._label:
+            # Check all the leaves
+            for subtree in self._subtrees:
+                (x1, y1, x2, y2) = subtree.bbox()
+                if bot + self._yspace > y1:
+                    subtree.move(0, bot + self._yspace - y1)
+
+            return self._subtrees
+        else:
+            moved = [child]
+            index = self._subtrees.index(child)
+
+            # Check leaves to our right.
+            x = right + self._xspace
+            for i in range(index + 1, len(self._subtrees)):
+                (x1, y1, x2, y2) = self._subtrees[i].bbox()
+                if x > x1:
+                    self._subtrees[i].move(x - x1, 0)
+                    x += x2 - x1 + self._xspace
+                    moved.append(self._subtrees[i])
+
+            # Check leaves to our left.
+            x = left - self._xspace
+            for i in range(index - 1, -1, -1):
+                (x1, y1, x2, y2) = self._subtrees[i].bbox()
+                if x < x2:
+                    self._subtrees[i].move(x - x2, 0)
+                    x -= x2 - x1 + self._xspace
+                    moved.append(self._subtrees[i])
+
+            # Check the node
+            (x1, y1, x2, y2) = self._label.bbox()
+            if y2 > top - self._yspace:
+                self._label.move(0, top - self._yspace - y2)
+                moved = self._subtrees
+
+        # Return a list of the nodes we moved
+        return moved
+
+    def _maintain_order_horizontal(self, child):
+        (left, top, right, bot) = child.bbox()
+
+        if child is self._label:
+            # Check all the leaves
+            for subtree in self._subtrees:
+                (x1, y1, x2, y2) = subtree.bbox()
+                if right + self._xspace > x1:
+                    subtree.move(right + self._xspace - x1)
+
+            return self._subtrees
+        else:
+            moved = [child]
+            index = self._subtrees.index(child)
+
+            # Check leaves below us.
+            y = bot + self._yspace
+            for i in range(index + 1, len(self._subtrees)):
+                (x1, y1, x2, y2) = self._subtrees[i].bbox()
+                if y > y1:
+                    self._subtrees[i].move(0, y - y1)
+                    y += y2 - y1 + self._yspace
+                    moved.append(self._subtrees[i])
+
+            # Check leaves above us
+            y = top - self._yspace
+            for i in range(index - 1, -1, -1):
+                (x1, y1, x2, y2) = self._subtrees[i].bbox()
+                if y < y2:
+                    self._subtrees[i].move(0, y - y2)
+                    y -= y2 - y1 + self._yspace
+                    moved.append(self._subtrees[i])
+
+            # Check the node
+            (x1, y1, x2, y2) = self._label.bbox()
+            if x2 > left - self._xspace:
+                self._label.move(left - self._xspace - x2, 0)
+                moved = self._subtrees
+
+        # Return a list of the nodes we moved
+        return moved
+
+    def _manage_horizontal(self):
+        (nodex, nodey) = self._node_bottom()
+
+        # Put the subtrees in a line.
+        y = 20
+        for subtree in self._subtrees:
+            subtree_bbox = subtree.bbox()
+            dx = nodex - subtree_bbox[0] + self._xspace
+            dy = y - subtree_bbox[1]
+            subtree.move(dx, dy)
+            y += subtree_bbox[3] - subtree_bbox[1] + self._yspace
+
+        # Find the center of their tops.
+        center = 0.0
+        for subtree in self._subtrees:
+            center += self._subtree_top(subtree)[1]
+        center /= len(self._subtrees)
+
+        # Center the subtrees with the node.
+        for subtree in self._subtrees:
+            subtree.move(0, nodey - center)
+
+    def _manage_vertical(self):
+        (nodex, nodey) = self._node_bottom()
+
+        # Put the subtrees in a line.
+        x = 0
+        for subtree in self._subtrees:
+            subtree_bbox = subtree.bbox()
+            dy = nodey - subtree_bbox[1] + self._yspace
+            dx = x - subtree_bbox[0]
+            subtree.move(dx, dy)
+            x += subtree_bbox[2] - subtree_bbox[0] + self._xspace
+
+        # Find the center of their tops.
+        center = 0.0
+        for subtree in self._subtrees:
+            center += self._subtree_top(subtree)[0] / len(self._subtrees)
+
+        # Center the subtrees with the node.
+        for subtree in self._subtrees:
+            subtree.move(nodex - center, 0)
+
+    def _manage(self):
+        self._managing = True
+        (nodex, nodey) = self._node_bottom()
+        if len(self._subtrees) == 0:
+            return
+
+        if self._horizontal:
+            self._manage_horizontal()
+        else:
+            self._manage_vertical()
+
+        # Update lines to subtrees.
+        for subtree in self._subtrees:
+            self._update(subtree)
+
+        self._managing = False
+
+    def __repr__(self):
+        return f"[TreeSeg {self._label}: {self._subtrees}]"
+
+
+def _tree_to_treeseg(
+    canvas,
+    t,
+    make_node,
+    make_leaf,
+    tree_attribs,
+    node_attribs,
+    leaf_attribs,
+    loc_attribs,
+):
+    if isinstance(t, Tree):
+        label = make_node(canvas, t.label(), **node_attribs)
+        subtrees = [
+            _tree_to_treeseg(
+                canvas,
+                child,
+                make_node,
+                make_leaf,
+                tree_attribs,
+                node_attribs,
+                leaf_attribs,
+                loc_attribs,
+            )
+            for child in t
+        ]
+        return TreeSegmentWidget(canvas, label, subtrees, **tree_attribs)
+    else:
+        return make_leaf(canvas, t, **leaf_attribs)
+
+
+def tree_to_treesegment(
+    canvas, t, make_node=TextWidget, make_leaf=TextWidget, **attribs
+):
+    """
+    Convert a Tree into a ``TreeSegmentWidget``.
+
+    :param make_node: A ``CanvasWidget`` constructor or a function that
+        creates ``CanvasWidgets``.  ``make_node`` is used to convert
+        the Tree's nodes into ``CanvasWidgets``.  If no constructor
+        is specified, then ``TextWidget`` will be used.
+    :param make_leaf: A ``CanvasWidget`` constructor or a function that
+        creates ``CanvasWidgets``.  ``make_leaf`` is used to convert
+        the Tree's leafs into ``CanvasWidgets``.  If no constructor
+        is specified, then ``TextWidget`` will be used.
+    :param attribs: Attributes for the canvas widgets that make up the
+        returned ``TreeSegmentWidget``.  Any attribute beginning with
+        ``'tree_'`` will be passed to all ``TreeSegmentWidgets`` (with
+        the ``'tree_'`` prefix removed.  Any attribute beginning with
+        ``'node_'`` will be passed to all nodes.  Any attribute
+        beginning with ``'leaf_'`` will be passed to all leaves.  And
+        any attribute beginning with ``'loc_'`` will be passed to all
+        text locations (for Trees).
+    """
+    # Process attribs.
+    tree_attribs = {}
+    node_attribs = {}
+    leaf_attribs = {}
+    loc_attribs = {}
+
+    for (key, value) in list(attribs.items()):
+        if key[:5] == "tree_":
+            tree_attribs[key[5:]] = value
+        elif key[:5] == "node_":
+            node_attribs[key[5:]] = value
+        elif key[:5] == "leaf_":
+            leaf_attribs[key[5:]] = value
+        elif key[:4] == "loc_":
+            loc_attribs[key[4:]] = value
+        else:
+            raise ValueError("Bad attribute: %s" % key)
+    return _tree_to_treeseg(
+        canvas,
+        t,
+        make_node,
+        make_leaf,
+        tree_attribs,
+        node_attribs,
+        leaf_attribs,
+        loc_attribs,
+    )
+
+
+##//////////////////////////////////////////////////////
+##  Tree Widget
+##//////////////////////////////////////////////////////
+
+
+class TreeWidget(CanvasWidget):
+    """
+    A canvas widget that displays a single Tree.
+    ``TreeWidget`` manages a group of ``TreeSegmentWidgets`` that are
+    used to display a Tree.
+
+    Attributes:
+
+      - ``node_attr``: Sets the attribute ``attr`` on all of the
+        node widgets for this ``TreeWidget``.
+      - ``node_attr``: Sets the attribute ``attr`` on all of the
+        leaf widgets for this ``TreeWidget``.
+      - ``loc_attr``: Sets the attribute ``attr`` on all of the
+        location widgets for this ``TreeWidget`` (if it was built from
+        a Tree).  Note that a location widget is a ``TextWidget``.
+
+      - ``xspace``: The amount of horizontal space to leave between
+        subtrees when managing this widget.  Default value is 10.
+      - ``yspace``: The amount of space to place between the node and
+        its children when managing this widget.  Default value is 15.
+
+      - ``line_color``: The color of the lines connecting each expanded
+        node to its subtrees.
+      - ``roof_color``: The color of the outline of the triangular roof
+        for collapsed trees.
+      - ``roof_fill``: The fill color for the triangular roof for
+        collapsed trees.
+      - ``width``
+
+      - ``orientation``: Determines whether the tree branches downwards
+        or rightwards.  Possible values are ``'horizontal'`` and
+        ``'vertical'``.  The default value is ``'vertical'`` (i.e.,
+        branch downwards).
+
+      - ``shapeable``: whether the subtrees can be independently
+        dragged by the user.  THIS property simply sets the
+        ``DRAGGABLE`` property on all of the ``TreeWidget``'s tree
+        segments.
+      - ``draggable``: whether the widget can be dragged by the user.
+    """
+
+    def __init__(
+        self, canvas, t, make_node=TextWidget, make_leaf=TextWidget, **attribs
+    ):
+        # Node & leaf canvas widget constructors
+        self._make_node = make_node
+        self._make_leaf = make_leaf
+        self._tree = t
+
+        # Attributes.
+        self._nodeattribs = {}
+        self._leafattribs = {}
+        self._locattribs = {"color": "#008000"}
+        self._line_color = "#008080"
+        self._line_width = 1
+        self._roof_color = "#008080"
+        self._roof_fill = "#c0c0c0"
+        self._shapeable = False
+        self._xspace = 10
+        self._yspace = 10
+        self._orientation = "vertical"
+        self._ordered = False
+
+        # Build trees.
+        self._keys = {}  # treeseg -> key
+        self._expanded_trees = {}
+        self._collapsed_trees = {}
+        self._nodes = []
+        self._leaves = []
+        # self._locs = []
+        self._make_collapsed_trees(canvas, t, ())
+        self._treeseg = self._make_expanded_tree(canvas, t, ())
+        self._add_child_widget(self._treeseg)
+
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    def expanded_tree(self, *path_to_tree):
+        """
+        Return the ``TreeSegmentWidget`` for the specified subtree.
+
+        :param path_to_tree: A list of indices i1, i2, ..., in, where
+            the desired widget is the widget corresponding to
+            ``tree.children()[i1].children()[i2]....children()[in]``.
+            For the root, the path is ``()``.
+        """
+        return self._expanded_trees[path_to_tree]
+
+    def collapsed_tree(self, *path_to_tree):
+        """
+        Return the ``TreeSegmentWidget`` for the specified subtree.
+
+        :param path_to_tree: A list of indices i1, i2, ..., in, where
+            the desired widget is the widget corresponding to
+            ``tree.children()[i1].children()[i2]....children()[in]``.
+            For the root, the path is ``()``.
+        """
+        return self._collapsed_trees[path_to_tree]
+
+    def bind_click_trees(self, callback, button=1):
+        """
+        Add a binding to all tree segments.
+        """
+        for tseg in list(self._expanded_trees.values()):
+            tseg.bind_click(callback, button)
+        for tseg in list(self._collapsed_trees.values()):
+            tseg.bind_click(callback, button)
+
+    def bind_drag_trees(self, callback, button=1):
+        """
+        Add a binding to all tree segments.
+        """
+        for tseg in list(self._expanded_trees.values()):
+            tseg.bind_drag(callback, button)
+        for tseg in list(self._collapsed_trees.values()):
+            tseg.bind_drag(callback, button)
+
+    def bind_click_leaves(self, callback, button=1):
+        """
+        Add a binding to all leaves.
+        """
+        for leaf in self._leaves:
+            leaf.bind_click(callback, button)
+        for leaf in self._leaves:
+            leaf.bind_click(callback, button)
+
+    def bind_drag_leaves(self, callback, button=1):
+        """
+        Add a binding to all leaves.
+        """
+        for leaf in self._leaves:
+            leaf.bind_drag(callback, button)
+        for leaf in self._leaves:
+            leaf.bind_drag(callback, button)
+
+    def bind_click_nodes(self, callback, button=1):
+        """
+        Add a binding to all nodes.
+        """
+        for node in self._nodes:
+            node.bind_click(callback, button)
+        for node in self._nodes:
+            node.bind_click(callback, button)
+
+    def bind_drag_nodes(self, callback, button=1):
+        """
+        Add a binding to all nodes.
+        """
+        for node in self._nodes:
+            node.bind_drag(callback, button)
+        for node in self._nodes:
+            node.bind_drag(callback, button)
+
+    def _make_collapsed_trees(self, canvas, t, key):
+        if not isinstance(t, Tree):
+            return
+        make_node = self._make_node
+        make_leaf = self._make_leaf
+
+        node = make_node(canvas, t.label(), **self._nodeattribs)
+        self._nodes.append(node)
+        leaves = [make_leaf(canvas, l, **self._leafattribs) for l in t.leaves()]
+        self._leaves += leaves
+        treeseg = TreeSegmentWidget(
+            canvas,
+            node,
+            leaves,
+            roof=1,
+            color=self._roof_color,
+            fill=self._roof_fill,
+            width=self._line_width,
+        )
+
+        self._collapsed_trees[key] = treeseg
+        self._keys[treeseg] = key
+        # self._add_child_widget(treeseg)
+        treeseg.hide()
+
+        # Build trees for children.
+        for i in range(len(t)):
+            child = t[i]
+            self._make_collapsed_trees(canvas, child, key + (i,))
+
+    def _make_expanded_tree(self, canvas, t, key):
+        make_node = self._make_node
+        make_leaf = self._make_leaf
+
+        if isinstance(t, Tree):
+            node = make_node(canvas, t.label(), **self._nodeattribs)
+            self._nodes.append(node)
+            children = t
+            subtrees = [
+                self._make_expanded_tree(canvas, children[i], key + (i,))
+                for i in range(len(children))
+            ]
+            treeseg = TreeSegmentWidget(
+                canvas, node, subtrees, color=self._line_color, width=self._line_width
+            )
+            self._expanded_trees[key] = treeseg
+            self._keys[treeseg] = key
+            return treeseg
+        else:
+            leaf = make_leaf(canvas, t, **self._leafattribs)
+            self._leaves.append(leaf)
+            return leaf
+
+    def __setitem__(self, attr, value):
+        if attr[:5] == "node_":
+            for node in self._nodes:
+                node[attr[5:]] = value
+        elif attr[:5] == "leaf_":
+            for leaf in self._leaves:
+                leaf[attr[5:]] = value
+        elif attr == "line_color":
+            self._line_color = value
+            for tseg in list(self._expanded_trees.values()):
+                tseg["color"] = value
+        elif attr == "line_width":
+            self._line_width = value
+            for tseg in list(self._expanded_trees.values()):
+                tseg["width"] = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["width"] = value
+        elif attr == "roof_color":
+            self._roof_color = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["color"] = value
+        elif attr == "roof_fill":
+            self._roof_fill = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["fill"] = value
+        elif attr == "shapeable":
+            self._shapeable = value
+            for tseg in list(self._expanded_trees.values()):
+                tseg["draggable"] = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["draggable"] = value
+            for leaf in self._leaves:
+                leaf["draggable"] = value
+        elif attr == "xspace":
+            self._xspace = value
+            for tseg in list(self._expanded_trees.values()):
+                tseg["xspace"] = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["xspace"] = value
+            self.manage()
+        elif attr == "yspace":
+            self._yspace = value
+            for tseg in list(self._expanded_trees.values()):
+                tseg["yspace"] = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["yspace"] = value
+            self.manage()
+        elif attr == "orientation":
+            self._orientation = value
+            for tseg in list(self._expanded_trees.values()):
+                tseg["orientation"] = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["orientation"] = value
+            self.manage()
+        elif attr == "ordered":
+            self._ordered = value
+            for tseg in list(self._expanded_trees.values()):
+                tseg["ordered"] = value
+            for tseg in list(self._collapsed_trees.values()):
+                tseg["ordered"] = value
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr[:5] == "node_":
+            return self._nodeattribs.get(attr[5:], None)
+        elif attr[:5] == "leaf_":
+            return self._leafattribs.get(attr[5:], None)
+        elif attr[:4] == "loc_":
+            return self._locattribs.get(attr[4:], None)
+        elif attr == "line_color":
+            return self._line_color
+        elif attr == "line_width":
+            return self._line_width
+        elif attr == "roof_color":
+            return self._roof_color
+        elif attr == "roof_fill":
+            return self._roof_fill
+        elif attr == "shapeable":
+            return self._shapeable
+        elif attr == "xspace":
+            return self._xspace
+        elif attr == "yspace":
+            return self._yspace
+        elif attr == "orientation":
+            return self._orientation
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def _tags(self):
+        return []
+
+    def _manage(self):
+        segs = list(self._expanded_trees.values()) + list(
+            self._collapsed_trees.values()
+        )
+        for tseg in segs:
+            if tseg.hidden():
+                tseg.show()
+                tseg.manage()
+                tseg.hide()
+
+    def toggle_collapsed(self, treeseg):
+        """
+        Collapse/expand a tree.
+        """
+        old_treeseg = treeseg
+        if old_treeseg["roof"]:
+            new_treeseg = self._expanded_trees[self._keys[old_treeseg]]
+        else:
+            new_treeseg = self._collapsed_trees[self._keys[old_treeseg]]
+
+        # Replace the old tree with the new tree.
+        if old_treeseg.parent() is self:
+            self._remove_child_widget(old_treeseg)
+            self._add_child_widget(new_treeseg)
+            self._treeseg = new_treeseg
+        else:
+            old_treeseg.parent().replace_child(old_treeseg, new_treeseg)
+
+        # Move the new tree to where the old tree was.  Show it first,
+        # so we can find its bounding box.
+        new_treeseg.show()
+        (newx, newy) = new_treeseg.label().bbox()[:2]
+        (oldx, oldy) = old_treeseg.label().bbox()[:2]
+        new_treeseg.move(oldx - newx, oldy - newy)
+
+        # Hide the old tree
+        old_treeseg.hide()
+
+        # We could do parent.manage() here instead, if we wanted.
+        new_treeseg.parent().update(new_treeseg)
+
+
+##//////////////////////////////////////////////////////
+##  draw_trees
+##//////////////////////////////////////////////////////
+
+
+class TreeView:
+    def __init__(self, *trees):
+        from math import ceil, sqrt
+
+        self._trees = trees
+
+        self._top = Tk()
+        self._top.title("NLTK")
+        self._top.bind("<Control-x>", self.destroy)
+        self._top.bind("<Control-q>", self.destroy)
+
+        cf = self._cframe = CanvasFrame(self._top)
+        self._top.bind("<Control-p>", self._cframe.print_to_file)
+
+        # Size is variable.
+        self._size = IntVar(self._top)
+        self._size.set(12)
+        bold = ("helvetica", -self._size.get(), "bold")
+        helv = ("helvetica", -self._size.get())
+
+        # Lay the trees out in a square.
+        self._width = int(ceil(sqrt(len(trees))))
+        self._widgets = []
+        for i in range(len(trees)):
+            widget = TreeWidget(
+                cf.canvas(),
+                trees[i],
+                node_font=bold,
+                leaf_color="#008040",
+                node_color="#004080",
+                roof_color="#004040",
+                roof_fill="white",
+                line_color="#004040",
+                draggable=1,
+                leaf_font=helv,
+            )
+            widget.bind_click_trees(widget.toggle_collapsed)
+            self._widgets.append(widget)
+            cf.add_widget(widget, 0, 0)
+
+        self._layout()
+        self._cframe.pack(expand=1, fill="both")
+        self._init_menubar()
+
+    def _layout(self):
+        i = x = y = ymax = 0
+        width = self._width
+        for i in range(len(self._widgets)):
+            widget = self._widgets[i]
+            (oldx, oldy) = widget.bbox()[:2]
+            if i % width == 0:
+                y = ymax
+                x = 0
+            widget.move(x - oldx, y - oldy)
+            x = widget.bbox()[2] + 10
+            ymax = max(ymax, widget.bbox()[3] + 10)
+
+    def _init_menubar(self):
+        menubar = Menu(self._top)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(
+            label="Print to Postscript",
+            underline=0,
+            command=self._cframe.print_to_file,
+            accelerator="Ctrl-p",
+        )
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-x"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        zoommenu = Menu(menubar, tearoff=0)
+        zoommenu.add_radiobutton(
+            label="Tiny",
+            variable=self._size,
+            underline=0,
+            value=10,
+            command=self.resize,
+        )
+        zoommenu.add_radiobutton(
+            label="Small",
+            variable=self._size,
+            underline=0,
+            value=12,
+            command=self.resize,
+        )
+        zoommenu.add_radiobutton(
+            label="Medium",
+            variable=self._size,
+            underline=0,
+            value=14,
+            command=self.resize,
+        )
+        zoommenu.add_radiobutton(
+            label="Large",
+            variable=self._size,
+            underline=0,
+            value=28,
+            command=self.resize,
+        )
+        zoommenu.add_radiobutton(
+            label="Huge",
+            variable=self._size,
+            underline=0,
+            value=50,
+            command=self.resize,
+        )
+        menubar.add_cascade(label="Zoom", underline=0, menu=zoommenu)
+
+        self._top.config(menu=menubar)
+
+    def resize(self, *e):
+        bold = ("helvetica", -self._size.get(), "bold")
+        helv = ("helvetica", -self._size.get())
+        xspace = self._size.get()
+        yspace = self._size.get()
+        for widget in self._widgets:
+            widget["node_font"] = bold
+            widget["leaf_font"] = helv
+            widget["xspace"] = xspace
+            widget["yspace"] = yspace
+            if self._size.get() < 20:
+                widget["line_width"] = 1
+            elif self._size.get() < 30:
+                widget["line_width"] = 2
+            else:
+                widget["line_width"] = 3
+        self._layout()
+
+    def destroy(self, *e):
+        if self._top is None:
+            return
+        self._top.destroy()
+        self._top = None
+
+    def mainloop(self, *args, **kwargs):
+        """
+        Enter the Tkinter mainloop.  This function must be called if
+        this demo is created from a non-interactive program (e.g.
+        from a secript); otherwise, the demo will close as soon as
+        the script completes.
+        """
+        if in_idle():
+            return
+        self._top.mainloop(*args, **kwargs)
+
+
+def draw_trees(*trees):
+    """
+    Open a new window containing a graphical diagram of the given
+    trees.
+
+    :rtype: None
+    """
+    TreeView(*trees).mainloop()
+    return
+
+
+##//////////////////////////////////////////////////////
+##  Demo Code
+##//////////////////////////////////////////////////////
+
+
+def demo():
+    import random
+
+    def fill(cw):
+        cw["fill"] = "#%06d" % random.randint(0, 999999)
+
+    cf = CanvasFrame(width=550, height=450, closeenough=2)
+
+    t = Tree.fromstring(
+        """
+    (S (NP the very big cat)
+       (VP (Adv sorta) (V saw) (NP (Det the) (N dog))))"""
+    )
+
+    tc = TreeWidget(
+        cf.canvas(),
+        t,
+        draggable=1,
+        node_font=("helvetica", -14, "bold"),
+        leaf_font=("helvetica", -12, "italic"),
+        roof_fill="white",
+        roof_color="black",
+        leaf_color="green4",
+        node_color="blue2",
+    )
+    cf.add_widget(tc, 10, 10)
+
+    def boxit(canvas, text):
+        big = ("helvetica", -16, "bold")
+        return BoxWidget(canvas, TextWidget(canvas, text, font=big), fill="green")
+
+    def ovalit(canvas, text):
+        return OvalWidget(canvas, TextWidget(canvas, text), fill="cyan")
+
+    treetok = Tree.fromstring("(S (NP this tree) (VP (V is) (AdjP shapeable)))")
+    tc2 = TreeWidget(cf.canvas(), treetok, boxit, ovalit, shapeable=1)
+
+    def color(node):
+        node["color"] = "#%04d00" % random.randint(0, 9999)
+
+    def color2(treeseg):
+        treeseg.label()["fill"] = "#%06d" % random.randint(0, 9999)
+        treeseg.label().child()["color"] = "white"
+
+    tc.bind_click_trees(tc.toggle_collapsed)
+    tc2.bind_click_trees(tc2.toggle_collapsed)
+    tc.bind_click_nodes(color, 3)
+    tc2.expanded_tree(1).bind_click(color2, 3)
+    tc2.expanded_tree().bind_click(color2, 3)
+
+    paren = ParenWidget(cf.canvas(), tc2)
+    cf.add_widget(paren, tc.bbox()[2] + 10, 10)
+
+    tree3 = Tree.fromstring(
+        """
+    (S (NP this tree) (AUX was)
+       (VP (V built) (PP (P with) (NP (N tree_to_treesegment)))))"""
+    )
+    tc3 = tree_to_treesegment(
+        cf.canvas(), tree3, tree_color="green4", tree_xspace=2, tree_width=2
+    )
+    tc3["draggable"] = 1
+    cf.add_widget(tc3, 10, tc.bbox()[3] + 10)
+
+    def orientswitch(treewidget):
+        if treewidget["orientation"] == "horizontal":
+            treewidget.expanded_tree(1, 1).subtrees()[0].set_text("vertical")
+            treewidget.collapsed_tree(1, 1).subtrees()[0].set_text("vertical")
+            treewidget.collapsed_tree(1).subtrees()[1].set_text("vertical")
+            treewidget.collapsed_tree().subtrees()[3].set_text("vertical")
+            treewidget["orientation"] = "vertical"
+        else:
+            treewidget.expanded_tree(1, 1).subtrees()[0].set_text("horizontal")
+            treewidget.collapsed_tree(1, 1).subtrees()[0].set_text("horizontal")
+            treewidget.collapsed_tree(1).subtrees()[1].set_text("horizontal")
+            treewidget.collapsed_tree().subtrees()[3].set_text("horizontal")
+            treewidget["orientation"] = "horizontal"
+
+    text = """
+Try clicking, right clicking, and dragging
+different elements of each of the trees.
+The top-left tree is a TreeWidget built from
+a Tree.  The top-right is a TreeWidget built
+from a Tree, using non-default widget
+constructors for the nodes & leaves (BoxWidget
+and OvalWidget).  The bottom-left tree is
+built from tree_to_treesegment."""
+    twidget = TextWidget(cf.canvas(), text.strip())
+    textbox = BoxWidget(cf.canvas(), twidget, fill="white", draggable=1)
+    cf.add_widget(textbox, tc3.bbox()[2] + 10, tc2.bbox()[3] + 10)
+
+    tree4 = Tree.fromstring("(S (NP this tree) (VP (V is) (Adj horizontal)))")
+    tc4 = TreeWidget(
+        cf.canvas(),
+        tree4,
+        draggable=1,
+        line_color="brown2",
+        roof_color="brown2",
+        node_font=("helvetica", -12, "bold"),
+        node_color="brown4",
+        orientation="horizontal",
+    )
+    tc4.manage()
+    cf.add_widget(tc4, tc3.bbox()[2] + 10, textbox.bbox()[3] + 10)
+    tc4.bind_click(orientswitch)
+    tc4.bind_click_trees(tc4.toggle_collapsed, 3)
+
+    # Run mainloop
+    cf.mainloop()
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/draw/util.py

@@ -0,0 +1,2575 @@
+# Natural Language Toolkit: Drawing utilities
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Tools for graphically displaying and interacting with the objects and
+processing classes defined by the Toolkit.  These tools are primarily
+intended to help students visualize the objects that they create.
+
+The graphical tools are typically built using "canvas widgets", each
+of which encapsulates the graphical elements and bindings used to
+display a complex object on a Tkinter ``Canvas``.  For example, NLTK
+defines canvas widgets for displaying trees and directed graphs, as
+well as a number of simpler widgets.  These canvas widgets make it
+easier to build new graphical tools and demos.  See the class
+documentation for ``CanvasWidget`` for more information.
+
+The ``nltk.draw`` module defines the abstract ``CanvasWidget`` base
+class, and a number of simple canvas widgets.  The remaining canvas
+widgets are defined by submodules, such as ``nltk.draw.tree``.
+
+The ``nltk.draw`` module also defines ``CanvasFrame``, which
+encapsulates a ``Canvas`` and its scrollbars.  It uses a
+``ScrollWatcherWidget`` to ensure that all canvas widgets contained on
+its canvas are within the scroll region.
+
+Acknowledgements: Many of the ideas behind the canvas widget system
+are derived from ``CLIG``, a Tk-based grapher for linguistic data
+structures.  For more information, see the CLIG
+homepage (http://www.ags.uni-sb.de/~konrad/clig.html).
+
+"""
+from abc import ABCMeta, abstractmethod
+from tkinter import (
+    RAISED,
+    Button,
+    Canvas,
+    Entry,
+    Frame,
+    Label,
+    Menu,
+    Menubutton,
+    Scrollbar,
+    StringVar,
+    Text,
+    Tk,
+    Toplevel,
+    Widget,
+)
+from tkinter.filedialog import asksaveasfilename
+
+from nltk.util import in_idle
+
+##//////////////////////////////////////////////////////
+##  CanvasWidget
+##//////////////////////////////////////////////////////
+
+
+class CanvasWidget(metaclass=ABCMeta):
+    """
+    A collection of graphical elements and bindings used to display a
+    complex object on a Tkinter ``Canvas``.  A canvas widget is
+    responsible for managing the ``Canvas`` tags and callback bindings
+    necessary to display and interact with the object.  Canvas widgets
+    are often organized into hierarchies, where parent canvas widgets
+    control aspects of their child widgets.
+
+    Each canvas widget is bound to a single ``Canvas``.  This ``Canvas``
+    is specified as the first argument to the ``CanvasWidget``'s
+    constructor.
+
+    Attributes.  Each canvas widget can support a variety of
+    "attributes", which control how the canvas widget is displayed.
+    Some typical examples attributes are ``color``, ``font``, and
+    ``radius``.  Each attribute has a default value.  This default
+    value can be overridden in the constructor, using keyword
+    arguments of the form ``attribute=value``:
+
+        >>> from nltk.draw.util import TextWidget
+        >>> cn = TextWidget(Canvas(), 'test', color='red')  # doctest: +SKIP
+
+    Attribute values can also be changed after a canvas widget has
+    been constructed, using the ``__setitem__`` operator:
+
+        >>> cn['font'] = 'times'  # doctest: +SKIP
+
+    The current value of an attribute value can be queried using the
+    ``__getitem__`` operator:
+
+        >>> cn['color']  # doctest: +SKIP
+        'red'
+
+    For a list of the attributes supported by a type of canvas widget,
+    see its class documentation.
+
+    Interaction.  The attribute ``'draggable'`` controls whether the
+    user can drag a canvas widget around the canvas.  By default,
+    canvas widgets are not draggable.
+
+    ``CanvasWidget`` provides callback support for two types of user
+    interaction: clicking and dragging.  The method ``bind_click``
+    registers a callback function that is called whenever the canvas
+    widget is clicked.  The method ``bind_drag`` registers a callback
+    function that is called after the canvas widget is dragged.  If
+    the user clicks or drags a canvas widget with no registered
+    callback function, then the interaction event will propagate to
+    its parent.  For each canvas widget, only one callback function
+    may be registered for an interaction event.  Callback functions
+    can be deregistered with the ``unbind_click`` and ``unbind_drag``
+    methods.
+
+    Subclassing.  ``CanvasWidget`` is an abstract class.  Subclasses
+    are required to implement the following methods:
+
+      - ``__init__``: Builds a new canvas widget.  It must perform the
+        following three tasks (in order):
+
+          - Create any new graphical elements.
+          - Call ``_add_child_widget`` on each child widget.
+          - Call the ``CanvasWidget`` constructor.
+      - ``_tags``: Returns a list of the canvas tags for all graphical
+        elements managed by this canvas widget, not including
+        graphical elements managed by its child widgets.
+      - ``_manage``: Arranges the child widgets of this canvas widget.
+        This is typically only called when the canvas widget is
+        created.
+      - ``_update``: Update this canvas widget in response to a
+        change in a single child.
+
+    For a ``CanvasWidget`` with no child widgets, the default
+    definitions for ``_manage`` and ``_update`` may be used.
+
+    If a subclass defines any attributes, then it should implement
+    ``__getitem__`` and ``__setitem__``.  If either of these methods is
+    called with an unknown attribute, then they should propagate the
+    request to ``CanvasWidget``.
+
+    Most subclasses implement a number of additional methods that
+    modify the ``CanvasWidget`` in some way.  These methods must call
+    ``parent.update(self)`` after making any changes to the canvas
+    widget's graphical elements.  The canvas widget must also call
+    ``parent.update(self)`` after changing any attribute value that
+    affects the shape or position of the canvas widget's graphical
+    elements.
+
+    :type __canvas: Tkinter.Canvas
+    :ivar __canvas: This ``CanvasWidget``'s canvas.
+
+    :type __parent: CanvasWidget or None
+    :ivar __parent: This ``CanvasWidget``'s hierarchical parent widget.
+    :type __children: list(CanvasWidget)
+    :ivar __children: This ``CanvasWidget``'s hierarchical child widgets.
+
+    :type __updating: bool
+    :ivar __updating: Is this canvas widget currently performing an
+        update?  If it is, then it will ignore any new update requests
+        from child widgets.
+
+    :type __draggable: bool
+    :ivar __draggable: Is this canvas widget draggable?
+    :type __press: event
+    :ivar __press: The ButtonPress event that we're currently handling.
+    :type __drag_x: int
+    :ivar __drag_x: Where it's been moved to (to find dx)
+    :type __drag_y: int
+    :ivar __drag_y: Where it's been moved to (to find dy)
+    :type __callbacks: dictionary
+    :ivar __callbacks: Registered callbacks.  Currently, four keys are
+        used: ``1``, ``2``, ``3``, and ``'drag'``.  The values are
+        callback functions.  Each callback function takes a single
+        argument, which is the ``CanvasWidget`` that triggered the
+        callback.
+    """
+
+    def __init__(self, canvas, parent=None, **attribs):
+        """
+        Create a new canvas widget.  This constructor should only be
+        called by subclass constructors; and it should be called only
+        "after" the subclass has constructed all graphical canvas
+        objects and registered all child widgets.
+
+        :param canvas: This canvas widget's canvas.
+        :type canvas: Tkinter.Canvas
+        :param parent: This canvas widget's hierarchical parent.
+        :type parent: CanvasWidget
+        :param attribs: The new canvas widget's attributes.
+        """
+        if self.__class__ == CanvasWidget:
+            raise TypeError("CanvasWidget is an abstract base class")
+
+        if not isinstance(canvas, Canvas):
+            raise TypeError("Expected a canvas!")
+
+        self.__canvas = canvas
+        self.__parent = parent
+
+        # If the subclass constructor called _add_child_widget, then
+        # self.__children will already exist.
+        if not hasattr(self, "_CanvasWidget__children"):
+            self.__children = []
+
+        # Is this widget hidden?
+        self.__hidden = 0
+
+        # Update control (prevents infinite loops)
+        self.__updating = 0
+
+        # Button-press and drag callback handling.
+        self.__press = None
+        self.__drag_x = self.__drag_y = 0
+        self.__callbacks = {}
+        self.__draggable = 0
+
+        # Set up attributes.
+        for (attr, value) in list(attribs.items()):
+            self[attr] = value
+
+        # Manage this canvas widget
+        self._manage()
+
+        # Register any new bindings
+        for tag in self._tags():
+            self.__canvas.tag_bind(tag, "<ButtonPress-1>", self.__press_cb)
+            self.__canvas.tag_bind(tag, "<ButtonPress-2>", self.__press_cb)
+            self.__canvas.tag_bind(tag, "<ButtonPress-3>", self.__press_cb)
+
+    ##//////////////////////////////////////////////////////
+    ##  Inherited methods.
+    ##//////////////////////////////////////////////////////
+
+    def bbox(self):
+        """
+        :return: A bounding box for this ``CanvasWidget``. The bounding
+            box is a tuple of four coordinates, *(xmin, ymin, xmax, ymax)*,
+            for a rectangle which encloses all of the canvas
+            widget's graphical elements.  Bounding box coordinates are
+            specified with respect to the coordinate space of the ``Canvas``.
+        :rtype: tuple(int, int, int, int)
+        """
+        if self.__hidden:
+            return (0, 0, 0, 0)
+        if len(self.tags()) == 0:
+            raise ValueError("No tags")
+        return self.__canvas.bbox(*self.tags())
+
+    def width(self):
+        """
+        :return: The width of this canvas widget's bounding box, in
+            its ``Canvas``'s coordinate space.
+        :rtype: int
+        """
+        if len(self.tags()) == 0:
+            raise ValueError("No tags")
+        bbox = self.__canvas.bbox(*self.tags())
+        return bbox[2] - bbox[0]
+
+    def height(self):
+        """
+        :return: The height of this canvas widget's bounding box, in
+            its ``Canvas``'s coordinate space.
+        :rtype: int
+        """
+        if len(self.tags()) == 0:
+            raise ValueError("No tags")
+        bbox = self.__canvas.bbox(*self.tags())
+        return bbox[3] - bbox[1]
+
+    def parent(self):
+        """
+        :return: The hierarchical parent of this canvas widget.
+            ``self`` is considered a subpart of its parent for
+            purposes of user interaction.
+        :rtype: CanvasWidget or None
+        """
+        return self.__parent
+
+    def child_widgets(self):
+        """
+        :return: A list of the hierarchical children of this canvas
+            widget.  These children are considered part of ``self``
+            for purposes of user interaction.
+        :rtype: list of CanvasWidget
+        """
+        return self.__children
+
+    def canvas(self):
+        """
+        :return: The canvas that this canvas widget is bound to.
+        :rtype: Tkinter.Canvas
+        """
+        return self.__canvas
+
+    def move(self, dx, dy):
+        """
+        Move this canvas widget by a given distance.  In particular,
+        shift the canvas widget right by ``dx`` pixels, and down by
+        ``dy`` pixels.  Both ``dx`` and ``dy`` may be negative, resulting
+        in leftward or upward movement.
+
+        :type dx: int
+        :param dx: The number of pixels to move this canvas widget
+            rightwards.
+        :type dy: int
+        :param dy: The number of pixels to move this canvas widget
+            downwards.
+        :rtype: None
+        """
+        if dx == dy == 0:
+            return
+        for tag in self.tags():
+            self.__canvas.move(tag, dx, dy)
+        if self.__parent:
+            self.__parent.update(self)
+
+    def moveto(self, x, y, anchor="NW"):
+        """
+        Move this canvas widget to the given location.  In particular,
+        shift the canvas widget such that the corner or side of the
+        bounding box specified by ``anchor`` is at location (``x``,
+        ``y``).
+
+        :param x,y: The location that the canvas widget should be moved
+            to.
+        :param anchor: The corner or side of the canvas widget that
+            should be moved to the specified location.  ``'N'``
+            specifies the top center; ``'NE'`` specifies the top right
+            corner; etc.
+        """
+        x1, y1, x2, y2 = self.bbox()
+        if anchor == "NW":
+            self.move(x - x1, y - y1)
+        if anchor == "N":
+            self.move(x - x1 / 2 - x2 / 2, y - y1)
+        if anchor == "NE":
+            self.move(x - x2, y - y1)
+        if anchor == "E":
+            self.move(x - x2, y - y1 / 2 - y2 / 2)
+        if anchor == "SE":
+            self.move(x - x2, y - y2)
+        if anchor == "S":
+            self.move(x - x1 / 2 - x2 / 2, y - y2)
+        if anchor == "SW":
+            self.move(x - x1, y - y2)
+        if anchor == "W":
+            self.move(x - x1, y - y1 / 2 - y2 / 2)
+
+    def destroy(self):
+        """
+        Remove this ``CanvasWidget`` from its ``Canvas``.  After a
+        ``CanvasWidget`` has been destroyed, it should not be accessed.
+
+        Note that you only need to destroy a top-level
+        ``CanvasWidget``; its child widgets will be destroyed
+        automatically.  If you destroy a non-top-level
+        ``CanvasWidget``, then the entire top-level widget will be
+        destroyed.
+
+        :raise ValueError: if this ``CanvasWidget`` has a parent.
+        :rtype: None
+        """
+        if self.__parent is not None:
+            self.__parent.destroy()
+            return
+
+        for tag in self.tags():
+            self.__canvas.tag_unbind(tag, "<ButtonPress-1>")
+            self.__canvas.tag_unbind(tag, "<ButtonPress-2>")
+            self.__canvas.tag_unbind(tag, "<ButtonPress-3>")
+        self.__canvas.delete(*self.tags())
+        self.__canvas = None
+
+    def update(self, child):
+        """
+        Update the graphical display of this canvas widget, and all of
+        its ancestors, in response to a change in one of this canvas
+        widget's children.
+
+        :param child: The child widget that changed.
+        :type child: CanvasWidget
+        """
+        if self.__hidden or child.__hidden:
+            return
+        # If we're already updating, then do nothing.  This prevents
+        # infinite loops when _update modifies its children.
+        if self.__updating:
+            return
+        self.__updating = 1
+
+        # Update this CanvasWidget.
+        self._update(child)
+
+        # Propagate update request to the parent.
+        if self.__parent:
+            self.__parent.update(self)
+
+        # We're done updating.
+        self.__updating = 0
+
+    def manage(self):
+        """
+        Arrange this canvas widget and all of its descendants.
+
+        :rtype: None
+        """
+        if self.__hidden:
+            return
+        for child in self.__children:
+            child.manage()
+        self._manage()
+
+    def tags(self):
+        """
+        :return: a list of the canvas tags for all graphical
+            elements managed by this canvas widget, including
+            graphical elements managed by its child widgets.
+        :rtype: list of int
+        """
+        if self.__canvas is None:
+            raise ValueError("Attempt to access a destroyed canvas widget")
+        tags = []
+        tags += self._tags()
+        for child in self.__children:
+            tags += child.tags()
+        return tags
+
+    def __setitem__(self, attr, value):
+        """
+        Set the value of the attribute ``attr`` to ``value``.  See the
+        class documentation for a list of attributes supported by this
+        canvas widget.
+
+        :rtype: None
+        """
+        if attr == "draggable":
+            self.__draggable = value
+        else:
+            raise ValueError("Unknown attribute %r" % attr)
+
+    def __getitem__(self, attr):
+        """
+        :return: the value of the attribute ``attr``.  See the class
+            documentation for a list of attributes supported by this
+            canvas widget.
+        :rtype: (any)
+        """
+        if attr == "draggable":
+            return self.__draggable
+        else:
+            raise ValueError("Unknown attribute %r" % attr)
+
+    def __repr__(self):
+        """
+        :return: a string representation of this canvas widget.
+        :rtype: str
+        """
+        return "<%s>" % self.__class__.__name__
+
+    def hide(self):
+        """
+        Temporarily hide this canvas widget.
+
+        :rtype: None
+        """
+        self.__hidden = 1
+        for tag in self.tags():
+            self.__canvas.itemconfig(tag, state="hidden")
+
+    def show(self):
+        """
+        Show a hidden canvas widget.
+
+        :rtype: None
+        """
+        self.__hidden = 0
+        for tag in self.tags():
+            self.__canvas.itemconfig(tag, state="normal")
+
+    def hidden(self):
+        """
+        :return: True if this canvas widget is hidden.
+        :rtype: bool
+        """
+        return self.__hidden
+
+    ##//////////////////////////////////////////////////////
+    ##  Callback interface
+    ##//////////////////////////////////////////////////////
+
+    def bind_click(self, callback, button=1):
+        """
+        Register a new callback that will be called whenever this
+        ``CanvasWidget`` is clicked on.
+
+        :type callback: function
+        :param callback: The callback function that will be called
+            whenever this ``CanvasWidget`` is clicked.  This function
+            will be called with this ``CanvasWidget`` as its argument.
+        :type button: int
+        :param button: Which button the user should use to click on
+            this ``CanvasWidget``.  Typically, this should be 1 (left
+            button), 3 (right button), or 2 (middle button).
+        """
+        self.__callbacks[button] = callback
+
+    def bind_drag(self, callback):
+        """
+        Register a new callback that will be called after this
+        ``CanvasWidget`` is dragged.  This implicitly makes this
+        ``CanvasWidget`` draggable.
+
+        :type callback: function
+        :param callback: The callback function that will be called
+            whenever this ``CanvasWidget`` is clicked.  This function
+            will be called with this ``CanvasWidget`` as its argument.
+        """
+        self.__draggable = 1
+        self.__callbacks["drag"] = callback
+
+    def unbind_click(self, button=1):
+        """
+        Remove a callback that was registered with ``bind_click``.
+
+        :type button: int
+        :param button: Which button the user should use to click on
+            this ``CanvasWidget``.  Typically, this should be 1 (left
+            button), 3 (right button), or 2 (middle button).
+        """
+        try:
+            del self.__callbacks[button]
+        except:
+            pass
+
+    def unbind_drag(self):
+        """
+        Remove a callback that was registered with ``bind_drag``.
+        """
+        try:
+            del self.__callbacks["drag"]
+        except:
+            pass
+
+    ##//////////////////////////////////////////////////////
+    ##  Callback internals
+    ##//////////////////////////////////////////////////////
+
+    def __press_cb(self, event):
+        """
+        Handle a button-press event:
+          - record the button press event in ``self.__press``
+          - register a button-release callback.
+          - if this CanvasWidget or any of its ancestors are
+            draggable, then register the appropriate motion callback.
+        """
+        # If we're already waiting for a button release, then ignore
+        # this new button press.
+        if (
+            self.__canvas.bind("<ButtonRelease-1>")
+            or self.__canvas.bind("<ButtonRelease-2>")
+            or self.__canvas.bind("<ButtonRelease-3>")
+        ):
+            return
+
+        # Unbind motion (just in case; this shouldn't be necessary)
+        self.__canvas.unbind("<Motion>")
+
+        # Record the button press event.
+        self.__press = event
+
+        # If any ancestor is draggable, set up a motion callback.
+        # (Only if they pressed button number 1)
+        if event.num == 1:
+            widget = self
+            while widget is not None:
+                if widget["draggable"]:
+                    widget.__start_drag(event)
+                    break
+                widget = widget.parent()
+
+        # Set up the button release callback.
+        self.__canvas.bind("<ButtonRelease-%d>" % event.num, self.__release_cb)
+
+    def __start_drag(self, event):
+        """
+        Begin dragging this object:
+          - register a motion callback
+          - record the drag coordinates
+        """
+        self.__canvas.bind("<Motion>", self.__motion_cb)
+        self.__drag_x = event.x
+        self.__drag_y = event.y
+
+    def __motion_cb(self, event):
+        """
+        Handle a motion event:
+          - move this object to the new location
+          - record the new drag coordinates
+        """
+        self.move(event.x - self.__drag_x, event.y - self.__drag_y)
+        self.__drag_x = event.x
+        self.__drag_y = event.y
+
+    def __release_cb(self, event):
+        """
+        Handle a release callback:
+          - unregister motion & button release callbacks.
+          - decide whether they clicked, dragged, or cancelled
+          - call the appropriate handler.
+        """
+        # Unbind the button release & motion callbacks.
+        self.__canvas.unbind("<ButtonRelease-%d>" % event.num)
+        self.__canvas.unbind("<Motion>")
+
+        # Is it a click or a drag?
+        if (
+            event.time - self.__press.time < 100
+            and abs(event.x - self.__press.x) + abs(event.y - self.__press.y) < 5
+        ):
+            # Move it back, if we were dragging.
+            if self.__draggable and event.num == 1:
+                self.move(
+                    self.__press.x - self.__drag_x, self.__press.y - self.__drag_y
+                )
+            self.__click(event.num)
+        elif event.num == 1:
+            self.__drag()
+
+        self.__press = None
+
+    def __drag(self):
+        """
+        If this ``CanvasWidget`` has a drag callback, then call it;
+        otherwise, find the closest ancestor with a drag callback, and
+        call it.  If no ancestors have a drag callback, do nothing.
+        """
+        if self.__draggable:
+            if "drag" in self.__callbacks:
+                cb = self.__callbacks["drag"]
+                try:
+                    cb(self)
+                except:
+                    print("Error in drag callback for %r" % self)
+        elif self.__parent is not None:
+            self.__parent.__drag()
+
+    def __click(self, button):
+        """
+        If this ``CanvasWidget`` has a drag callback, then call it;
+        otherwise, find the closest ancestor with a click callback, and
+        call it.  If no ancestors have a click callback, do nothing.
+        """
+        if button in self.__callbacks:
+            cb = self.__callbacks[button]
+            # try:
+            cb(self)
+            # except:
+            #    print('Error in click callback for %r' % self)
+            #    raise
+        elif self.__parent is not None:
+            self.__parent.__click(button)
+
+    ##//////////////////////////////////////////////////////
+    ##  Child/parent Handling
+    ##//////////////////////////////////////////////////////
+
+    def _add_child_widget(self, child):
+        """
+        Register a hierarchical child widget.  The child will be
+        considered part of this canvas widget for purposes of user
+        interaction.  ``_add_child_widget`` has two direct effects:
+          - It sets ``child``'s parent to this canvas widget.
+          - It adds ``child`` to the list of canvas widgets returned by
+            the ``child_widgets`` member function.
+
+        :param child: The new child widget.  ``child`` must not already
+            have a parent.
+        :type child: CanvasWidget
+        """
+        if not hasattr(self, "_CanvasWidget__children"):
+            self.__children = []
+        if child.__parent is not None:
+            raise ValueError(f"{child} already has a parent")
+        child.__parent = self
+        self.__children.append(child)
+
+    def _remove_child_widget(self, child):
+        """
+        Remove a hierarchical child widget.  This child will no longer
+        be considered part of this canvas widget for purposes of user
+        interaction.  ``_add_child_widget`` has two direct effects:
+          - It sets ``child``'s parent to None.
+          - It removes ``child`` from the list of canvas widgets
+            returned by the ``child_widgets`` member function.
+
+        :param child: The child widget to remove.  ``child`` must be a
+            child of this canvas widget.
+        :type child: CanvasWidget
+        """
+        self.__children.remove(child)
+        child.__parent = None
+
+    ##//////////////////////////////////////////////////////
+    ##  Defined by subclass
+    ##//////////////////////////////////////////////////////
+
+    @abstractmethod
+    def _tags(self):
+        """
+        :return: a list of canvas tags for all graphical elements
+            managed by this canvas widget, not including graphical
+            elements managed by its child widgets.
+        :rtype: list of int
+        """
+
+    def _manage(self):
+        """
+        Arrange the child widgets of this canvas widget.  This method
+        is called when the canvas widget is initially created.  It is
+        also called if the user calls the ``manage`` method on this
+        canvas widget or any of its ancestors.
+
+        :rtype: None
+        """
+
+    def _update(self, child):
+        """
+        Update this canvas widget in response to a change in one of
+        its children.
+
+        :param child: The child that changed.
+        :type child: CanvasWidget
+        :rtype: None
+        """
+
+
+##//////////////////////////////////////////////////////
+##  Basic widgets.
+##//////////////////////////////////////////////////////
+
+
+class TextWidget(CanvasWidget):
+    """
+    A canvas widget that displays a single string of text.
+
+    Attributes:
+      - ``color``: the color of the text.
+      - ``font``: the font used to display the text.
+      - ``justify``: justification for multi-line texts.  Valid values
+        are ``left``, ``center``, and ``right``.
+      - ``width``: the width of the text.  If the text is wider than
+        this width, it will be line-wrapped at whitespace.
+      - ``draggable``: whether the text can be dragged by the user.
+    """
+
+    def __init__(self, canvas, text, **attribs):
+        """
+        Create a new text widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :type text: str
+        :param text: The string of text to display.
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._text = text
+        self._tag = canvas.create_text(1, 1, text=text)
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    def __setitem__(self, attr, value):
+        if attr in ("color", "font", "justify", "width"):
+            if attr == "color":
+                attr = "fill"
+            self.canvas().itemconfig(self._tag, {attr: value})
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "width":
+            return int(self.canvas().itemcget(self._tag, attr))
+        elif attr in ("color", "font", "justify"):
+            if attr == "color":
+                attr = "fill"
+            return self.canvas().itemcget(self._tag, attr)
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def _tags(self):
+        return [self._tag]
+
+    def text(self):
+        """
+        :return: The text displayed by this text widget.
+        :rtype: str
+        """
+        return self.canvas().itemcget(self._tag, "TEXT")
+
+    def set_text(self, text):
+        """
+        Change the text that is displayed by this text widget.
+
+        :type text: str
+        :param text: The string of text to display.
+        :rtype: None
+        """
+        self.canvas().itemconfig(self._tag, text=text)
+        if self.parent() is not None:
+            self.parent().update(self)
+
+    def __repr__(self):
+        return "[Text: %r]" % self._text
+
+
+class SymbolWidget(TextWidget):
+    """
+    A canvas widget that displays special symbols, such as the
+    negation sign and the exists operator.  Symbols are specified by
+    name.  Currently, the following symbol names are defined: ``neg``,
+    ``disj``, ``conj``, ``lambda``, ``merge``, ``forall``, ``exists``,
+    ``subseteq``, ``subset``, ``notsubset``, ``emptyset``, ``imp``,
+    ``rightarrow``, ``equal``, ``notequal``, ``epsilon``.
+
+    Attributes:
+
+    - ``color``: the color of the text.
+    - ``draggable``: whether the text can be dragged by the user.
+
+    :cvar SYMBOLS: A dictionary mapping from symbols to the character
+        in the ``symbol`` font used to render them.
+    """
+
+    SYMBOLS = {
+        "neg": "\330",
+        "disj": "\332",
+        "conj": "\331",
+        "lambda": "\154",
+        "merge": "\304",
+        "forall": "\042",
+        "exists": "\044",
+        "subseteq": "\315",
+        "subset": "\314",
+        "notsubset": "\313",
+        "emptyset": "\306",
+        "imp": "\336",
+        "rightarrow": chr(222),  #'\256',
+        "equal": "\75",
+        "notequal": "\271",
+        "intersection": "\307",
+        "union": "\310",
+        "epsilon": "e",
+    }
+
+    def __init__(self, canvas, symbol, **attribs):
+        """
+        Create a new symbol widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :type symbol: str
+        :param symbol: The name of the symbol to display.
+        :param attribs: The new canvas widget's attributes.
+        """
+        attribs["font"] = "symbol"
+        TextWidget.__init__(self, canvas, "", **attribs)
+        self.set_symbol(symbol)
+
+    def symbol(self):
+        """
+        :return: the name of the symbol that is displayed by this
+            symbol widget.
+        :rtype: str
+        """
+        return self._symbol
+
+    def set_symbol(self, symbol):
+        """
+        Change the symbol that is displayed by this symbol widget.
+
+        :type symbol: str
+        :param symbol: The name of the symbol to display.
+        """
+        if symbol not in SymbolWidget.SYMBOLS:
+            raise ValueError("Unknown symbol: %s" % symbol)
+        self._symbol = symbol
+        self.set_text(SymbolWidget.SYMBOLS[symbol])
+
+    def __repr__(self):
+        return "[Symbol: %r]" % self._symbol
+
+    @staticmethod
+    def symbolsheet(size=20):
+        """
+        Open a new Tkinter window that displays the entire alphabet
+        for the symbol font.  This is useful for constructing the
+        ``SymbolWidget.SYMBOLS`` dictionary.
+        """
+        top = Tk()
+
+        def destroy(e, top=top):
+            top.destroy()
+
+        top.bind("q", destroy)
+        Button(top, text="Quit", command=top.destroy).pack(side="bottom")
+        text = Text(top, font=("helvetica", -size), width=20, height=30)
+        text.pack(side="left")
+        sb = Scrollbar(top, command=text.yview)
+        text["yscrollcommand"] = sb.set
+        sb.pack(side="right", fill="y")
+        text.tag_config("symbol", font=("symbol", -size))
+        for i in range(256):
+            if i in (0, 10):
+                continue  # null and newline
+            for k, v in list(SymbolWidget.SYMBOLS.items()):
+                if v == chr(i):
+                    text.insert("end", "%-10s\t" % k)
+                    break
+            else:
+                text.insert("end", "%-10d  \t" % i)
+            text.insert("end", "[%s]\n" % chr(i), "symbol")
+        top.mainloop()
+
+
+class AbstractContainerWidget(CanvasWidget):
+    """
+    An abstract class for canvas widgets that contain a single child,
+    such as ``BoxWidget`` and ``OvalWidget``.  Subclasses must define
+    a constructor, which should create any new graphical elements and
+    then call the ``AbstractCanvasContainer`` constructor.  Subclasses
+    must also define the ``_update`` method and the ``_tags`` method;
+    and any subclasses that define attributes should define
+    ``__setitem__`` and ``__getitem__``.
+    """
+
+    def __init__(self, canvas, child, **attribs):
+        """
+        Create a new container widget.  This constructor should only
+        be called by subclass constructors.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :param child: The container's child widget.  ``child`` must not
+            have a parent.
+        :type child: CanvasWidget
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._child = child
+        self._add_child_widget(child)
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    def _manage(self):
+        self._update(self._child)
+
+    def child(self):
+        """
+        :return: The child widget contained by this container widget.
+        :rtype: CanvasWidget
+        """
+        return self._child
+
+    def set_child(self, child):
+        """
+        Change the child widget contained by this container widget.
+
+        :param child: The new child widget.  ``child`` must not have a
+            parent.
+        :type child: CanvasWidget
+        :rtype: None
+        """
+        self._remove_child_widget(self._child)
+        self._add_child_widget(child)
+        self._child = child
+        self.update(child)
+
+    def __repr__(self):
+        name = self.__class__.__name__
+        if name[-6:] == "Widget":
+            name = name[:-6]
+        return f"[{name}: {self._child!r}]"
+
+
+class BoxWidget(AbstractContainerWidget):
+    """
+    A canvas widget that places a box around a child widget.
+
+    Attributes:
+      - ``fill``: The color used to fill the interior of the box.
+      - ``outline``: The color used to draw the outline of the box.
+      - ``width``: The width of the outline of the box.
+      - ``margin``: The number of pixels space left between the child
+        and the box.
+      - ``draggable``: whether the text can be dragged by the user.
+    """
+
+    def __init__(self, canvas, child, **attribs):
+        """
+        Create a new box widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :param child: The child widget.  ``child`` must not have a
+            parent.
+        :type child: CanvasWidget
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._child = child
+        self._margin = 1
+        self._box = canvas.create_rectangle(1, 1, 1, 1)
+        canvas.tag_lower(self._box)
+        AbstractContainerWidget.__init__(self, canvas, child, **attribs)
+
+    def __setitem__(self, attr, value):
+        if attr == "margin":
+            self._margin = value
+        elif attr in ("outline", "fill", "width"):
+            self.canvas().itemconfig(self._box, {attr: value})
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "margin":
+            return self._margin
+        elif attr == "width":
+            return float(self.canvas().itemcget(self._box, attr))
+        elif attr in ("outline", "fill", "width"):
+            return self.canvas().itemcget(self._box, attr)
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def _update(self, child):
+        (x1, y1, x2, y2) = child.bbox()
+        margin = self._margin + self["width"] / 2
+        self.canvas().coords(
+            self._box, x1 - margin, y1 - margin, x2 + margin, y2 + margin
+        )
+
+    def _tags(self):
+        return [self._box]
+
+
+class OvalWidget(AbstractContainerWidget):
+    """
+    A canvas widget that places a oval around a child widget.
+
+    Attributes:
+      - ``fill``: The color used to fill the interior of the oval.
+      - ``outline``: The color used to draw the outline of the oval.
+      - ``width``: The width of the outline of the oval.
+      - ``margin``: The number of pixels space left between the child
+        and the oval.
+      - ``draggable``: whether the text can be dragged by the user.
+      - ``double``: If true, then a double-oval is drawn.
+    """
+
+    def __init__(self, canvas, child, **attribs):
+        """
+        Create a new oval widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :param child: The child widget.  ``child`` must not have a
+            parent.
+        :type child: CanvasWidget
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._child = child
+        self._margin = 1
+        self._oval = canvas.create_oval(1, 1, 1, 1)
+        self._circle = attribs.pop("circle", False)
+        self._double = attribs.pop("double", False)
+        if self._double:
+            self._oval2 = canvas.create_oval(1, 1, 1, 1)
+        else:
+            self._oval2 = None
+        canvas.tag_lower(self._oval)
+        AbstractContainerWidget.__init__(self, canvas, child, **attribs)
+
+    def __setitem__(self, attr, value):
+        c = self.canvas()
+        if attr == "margin":
+            self._margin = value
+        elif attr == "double":
+            if value == True and self._oval2 is None:
+                # Copy attributes & position from self._oval.
+                x1, y1, x2, y2 = c.bbox(self._oval)
+                w = self["width"] * 2
+                self._oval2 = c.create_oval(
+                    x1 - w,
+                    y1 - w,
+                    x2 + w,
+                    y2 + w,
+                    outline=c.itemcget(self._oval, "outline"),
+                    width=c.itemcget(self._oval, "width"),
+                )
+                c.tag_lower(self._oval2)
+            if value == False and self._oval2 is not None:
+                c.delete(self._oval2)
+                self._oval2 = None
+        elif attr in ("outline", "fill", "width"):
+            c.itemconfig(self._oval, {attr: value})
+            if self._oval2 is not None and attr != "fill":
+                c.itemconfig(self._oval2, {attr: value})
+            if self._oval2 is not None and attr != "fill":
+                self.canvas().itemconfig(self._oval2, {attr: value})
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "margin":
+            return self._margin
+        elif attr == "double":
+            return self._double is not None
+        elif attr == "width":
+            return float(self.canvas().itemcget(self._oval, attr))
+        elif attr in ("outline", "fill", "width"):
+            return self.canvas().itemcget(self._oval, attr)
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    # The ratio between inscribed & circumscribed ovals
+    RATIO = 1.4142135623730949
+
+    def _update(self, child):
+        R = OvalWidget.RATIO
+        (x1, y1, x2, y2) = child.bbox()
+        margin = self._margin
+
+        # If we're a circle, pretend our contents are square.
+        if self._circle:
+            dx, dy = abs(x1 - x2), abs(y1 - y2)
+            if dx > dy:
+                y = (y1 + y2) / 2
+                y1, y2 = y - dx / 2, y + dx / 2
+            elif dy > dx:
+                x = (x1 + x2) / 2
+                x1, x2 = x - dy / 2, x + dy / 2
+
+        # Find the four corners.
+        left = int((x1 * (1 + R) + x2 * (1 - R)) / 2)
+        right = left + int((x2 - x1) * R)
+        top = int((y1 * (1 + R) + y2 * (1 - R)) / 2)
+        bot = top + int((y2 - y1) * R)
+        self.canvas().coords(
+            self._oval, left - margin, top - margin, right + margin, bot + margin
+        )
+        if self._oval2 is not None:
+            self.canvas().coords(
+                self._oval2,
+                left - margin + 2,
+                top - margin + 2,
+                right + margin - 2,
+                bot + margin - 2,
+            )
+
+    def _tags(self):
+        if self._oval2 is None:
+            return [self._oval]
+        else:
+            return [self._oval, self._oval2]
+
+
+class ParenWidget(AbstractContainerWidget):
+    """
+    A canvas widget that places a pair of parenthases around a child
+    widget.
+
+    Attributes:
+      - ``color``: The color used to draw the parenthases.
+      - ``width``: The width of the parenthases.
+      - ``draggable``: whether the text can be dragged by the user.
+    """
+
+    def __init__(self, canvas, child, **attribs):
+        """
+        Create a new parenthasis widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :param child: The child widget.  ``child`` must not have a
+            parent.
+        :type child: CanvasWidget
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._child = child
+        self._oparen = canvas.create_arc(1, 1, 1, 1, style="arc", start=90, extent=180)
+        self._cparen = canvas.create_arc(1, 1, 1, 1, style="arc", start=-90, extent=180)
+        AbstractContainerWidget.__init__(self, canvas, child, **attribs)
+
+    def __setitem__(self, attr, value):
+        if attr == "color":
+            self.canvas().itemconfig(self._oparen, outline=value)
+            self.canvas().itemconfig(self._cparen, outline=value)
+        elif attr == "width":
+            self.canvas().itemconfig(self._oparen, width=value)
+            self.canvas().itemconfig(self._cparen, width=value)
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "color":
+            return self.canvas().itemcget(self._oparen, "outline")
+        elif attr == "width":
+            return self.canvas().itemcget(self._oparen, "width")
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def _update(self, child):
+        (x1, y1, x2, y2) = child.bbox()
+        width = max((y2 - y1) / 6, 4)
+        self.canvas().coords(self._oparen, x1 - width, y1, x1 + width, y2)
+        self.canvas().coords(self._cparen, x2 - width, y1, x2 + width, y2)
+
+    def _tags(self):
+        return [self._oparen, self._cparen]
+
+
+class BracketWidget(AbstractContainerWidget):
+    """
+    A canvas widget that places a pair of brackets around a child
+    widget.
+
+    Attributes:
+      - ``color``: The color used to draw the brackets.
+      - ``width``: The width of the brackets.
+      - ``draggable``: whether the text can be dragged by the user.
+    """
+
+    def __init__(self, canvas, child, **attribs):
+        """
+        Create a new bracket widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :param child: The child widget.  ``child`` must not have a
+            parent.
+        :type child: CanvasWidget
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._child = child
+        self._obrack = canvas.create_line(1, 1, 1, 1, 1, 1, 1, 1)
+        self._cbrack = canvas.create_line(1, 1, 1, 1, 1, 1, 1, 1)
+        AbstractContainerWidget.__init__(self, canvas, child, **attribs)
+
+    def __setitem__(self, attr, value):
+        if attr == "color":
+            self.canvas().itemconfig(self._obrack, fill=value)
+            self.canvas().itemconfig(self._cbrack, fill=value)
+        elif attr == "width":
+            self.canvas().itemconfig(self._obrack, width=value)
+            self.canvas().itemconfig(self._cbrack, width=value)
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "color":
+            return self.canvas().itemcget(self._obrack, "outline")
+        elif attr == "width":
+            return self.canvas().itemcget(self._obrack, "width")
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def _update(self, child):
+        (x1, y1, x2, y2) = child.bbox()
+        width = max((y2 - y1) / 8, 2)
+        self.canvas().coords(
+            self._obrack, x1, y1, x1 - width, y1, x1 - width, y2, x1, y2
+        )
+        self.canvas().coords(
+            self._cbrack, x2, y1, x2 + width, y1, x2 + width, y2, x2, y2
+        )
+
+    def _tags(self):
+        return [self._obrack, self._cbrack]
+
+
+class SequenceWidget(CanvasWidget):
+    """
+    A canvas widget that keeps a list of canvas widgets in a
+    horizontal line.
+
+    Attributes:
+      - ``align``: The vertical alignment of the children.  Possible
+        values are ``'top'``, ``'center'``, and ``'bottom'``.  By
+        default, children are center-aligned.
+      - ``space``: The amount of horizontal space to place between
+        children.  By default, one pixel of space is used.
+      - ``ordered``: If true, then keep the children in their
+        original order.
+    """
+
+    def __init__(self, canvas, *children, **attribs):
+        """
+        Create a new sequence widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :param children: The widgets that should be aligned
+            horizontally.  Each child must not have a parent.
+        :type children: list(CanvasWidget)
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._align = "center"
+        self._space = 1
+        self._ordered = False
+        self._children = list(children)
+        for child in children:
+            self._add_child_widget(child)
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    def __setitem__(self, attr, value):
+        if attr == "align":
+            if value not in ("top", "bottom", "center"):
+                raise ValueError("Bad alignment: %r" % value)
+            self._align = value
+        elif attr == "space":
+            self._space = value
+        elif attr == "ordered":
+            self._ordered = value
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "align":
+            return self._align
+        elif attr == "space":
+            return self._space
+        elif attr == "ordered":
+            return self._ordered
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def _tags(self):
+        return []
+
+    def _yalign(self, top, bot):
+        if self._align == "top":
+            return top
+        if self._align == "bottom":
+            return bot
+        if self._align == "center":
+            return (top + bot) / 2
+
+    def _update(self, child):
+        # Align all children with child.
+        (left, top, right, bot) = child.bbox()
+        y = self._yalign(top, bot)
+        for c in self._children:
+            (x1, y1, x2, y2) = c.bbox()
+            c.move(0, y - self._yalign(y1, y2))
+
+        if self._ordered and len(self._children) > 1:
+            index = self._children.index(child)
+
+            x = right + self._space
+            for i in range(index + 1, len(self._children)):
+                (x1, y1, x2, y2) = self._children[i].bbox()
+                if x > x1:
+                    self._children[i].move(x - x1, 0)
+                    x += x2 - x1 + self._space
+
+            x = left - self._space
+            for i in range(index - 1, -1, -1):
+                (x1, y1, x2, y2) = self._children[i].bbox()
+                if x < x2:
+                    self._children[i].move(x - x2, 0)
+                    x -= x2 - x1 + self._space
+
+    def _manage(self):
+        if len(self._children) == 0:
+            return
+        child = self._children[0]
+
+        # Align all children with child.
+        (left, top, right, bot) = child.bbox()
+        y = self._yalign(top, bot)
+
+        index = self._children.index(child)
+
+        # Line up children to the right of child.
+        x = right + self._space
+        for i in range(index + 1, len(self._children)):
+            (x1, y1, x2, y2) = self._children[i].bbox()
+            self._children[i].move(x - x1, y - self._yalign(y1, y2))
+            x += x2 - x1 + self._space
+
+        # Line up children to the left of child.
+        x = left - self._space
+        for i in range(index - 1, -1, -1):
+            (x1, y1, x2, y2) = self._children[i].bbox()
+            self._children[i].move(x - x2, y - self._yalign(y1, y2))
+            x -= x2 - x1 + self._space
+
+    def __repr__(self):
+        return "[Sequence: " + repr(self._children)[1:-1] + "]"
+
+    # Provide an alias for the child_widgets() member.
+    children = CanvasWidget.child_widgets
+
+    def replace_child(self, oldchild, newchild):
+        """
+        Replace the child canvas widget ``oldchild`` with ``newchild``.
+        ``newchild`` must not have a parent.  ``oldchild``'s parent will
+        be set to None.
+
+        :type oldchild: CanvasWidget
+        :param oldchild: The child canvas widget to remove.
+        :type newchild: CanvasWidget
+        :param newchild: The canvas widget that should replace
+            ``oldchild``.
+        """
+        index = self._children.index(oldchild)
+        self._children[index] = newchild
+        self._remove_child_widget(oldchild)
+        self._add_child_widget(newchild)
+        self.update(newchild)
+
+    def remove_child(self, child):
+        """
+        Remove the given child canvas widget.  ``child``'s parent will
+        be set to None.
+
+        :type child: CanvasWidget
+        :param child: The child canvas widget to remove.
+        """
+        index = self._children.index(child)
+        del self._children[index]
+        self._remove_child_widget(child)
+        if len(self._children) > 0:
+            self.update(self._children[0])
+
+    def insert_child(self, index, child):
+        """
+        Insert a child canvas widget before a given index.
+
+        :type child: CanvasWidget
+        :param child: The canvas widget that should be inserted.
+        :type index: int
+        :param index: The index where the child widget should be
+            inserted.  In particular, the index of ``child`` will be
+            ``index``; and the index of any children whose indices were
+            greater than equal to ``index`` before ``child`` was
+            inserted will be incremented by one.
+        """
+        self._children.insert(index, child)
+        self._add_child_widget(child)
+
+
+class StackWidget(CanvasWidget):
+    """
+    A canvas widget that keeps a list of canvas widgets in a vertical
+    line.
+
+    Attributes:
+      - ``align``: The horizontal alignment of the children.  Possible
+        values are ``'left'``, ``'center'``, and ``'right'``.  By
+        default, children are center-aligned.
+      - ``space``: The amount of vertical space to place between
+        children.  By default, one pixel of space is used.
+      - ``ordered``: If true, then keep the children in their
+        original order.
+    """
+
+    def __init__(self, canvas, *children, **attribs):
+        """
+        Create a new stack widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :param children: The widgets that should be aligned
+            vertically.  Each child must not have a parent.
+        :type children: list(CanvasWidget)
+        :param attribs: The new canvas widget's attributes.
+        """
+        self._align = "center"
+        self._space = 1
+        self._ordered = False
+        self._children = list(children)
+        for child in children:
+            self._add_child_widget(child)
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    def __setitem__(self, attr, value):
+        if attr == "align":
+            if value not in ("left", "right", "center"):
+                raise ValueError("Bad alignment: %r" % value)
+            self._align = value
+        elif attr == "space":
+            self._space = value
+        elif attr == "ordered":
+            self._ordered = value
+        else:
+            CanvasWidget.__setitem__(self, attr, value)
+
+    def __getitem__(self, attr):
+        if attr == "align":
+            return self._align
+        elif attr == "space":
+            return self._space
+        elif attr == "ordered":
+            return self._ordered
+        else:
+            return CanvasWidget.__getitem__(self, attr)
+
+    def _tags(self):
+        return []
+
+    def _xalign(self, left, right):
+        if self._align == "left":
+            return left
+        if self._align == "right":
+            return right
+        if self._align == "center":
+            return (left + right) / 2
+
+    def _update(self, child):
+        # Align all children with child.
+        (left, top, right, bot) = child.bbox()
+        x = self._xalign(left, right)
+        for c in self._children:
+            (x1, y1, x2, y2) = c.bbox()
+            c.move(x - self._xalign(x1, x2), 0)
+
+        if self._ordered and len(self._children) > 1:
+            index = self._children.index(child)
+
+            y = bot + self._space
+            for i in range(index + 1, len(self._children)):
+                (x1, y1, x2, y2) = self._children[i].bbox()
+                if y > y1:
+                    self._children[i].move(0, y - y1)
+                    y += y2 - y1 + self._space
+
+            y = top - self._space
+            for i in range(index - 1, -1, -1):
+                (x1, y1, x2, y2) = self._children[i].bbox()
+                if y < y2:
+                    self._children[i].move(0, y - y2)
+                    y -= y2 - y1 + self._space
+
+    def _manage(self):
+        if len(self._children) == 0:
+            return
+        child = self._children[0]
+
+        # Align all children with child.
+        (left, top, right, bot) = child.bbox()
+        x = self._xalign(left, right)
+
+        index = self._children.index(child)
+
+        # Line up children below the child.
+        y = bot + self._space
+        for i in range(index + 1, len(self._children)):
+            (x1, y1, x2, y2) = self._children[i].bbox()
+            self._children[i].move(x - self._xalign(x1, x2), y - y1)
+            y += y2 - y1 + self._space
+
+        # Line up children above the child.
+        y = top - self._space
+        for i in range(index - 1, -1, -1):
+            (x1, y1, x2, y2) = self._children[i].bbox()
+            self._children[i].move(x - self._xalign(x1, x2), y - y2)
+            y -= y2 - y1 + self._space
+
+    def __repr__(self):
+        return "[Stack: " + repr(self._children)[1:-1] + "]"
+
+    # Provide an alias for the child_widgets() member.
+    children = CanvasWidget.child_widgets
+
+    def replace_child(self, oldchild, newchild):
+        """
+        Replace the child canvas widget ``oldchild`` with ``newchild``.
+        ``newchild`` must not have a parent.  ``oldchild``'s parent will
+        be set to None.
+
+        :type oldchild: CanvasWidget
+        :param oldchild: The child canvas widget to remove.
+        :type newchild: CanvasWidget
+        :param newchild: The canvas widget that should replace
+            ``oldchild``.
+        """
+        index = self._children.index(oldchild)
+        self._children[index] = newchild
+        self._remove_child_widget(oldchild)
+        self._add_child_widget(newchild)
+        self.update(newchild)
+
+    def remove_child(self, child):
+        """
+        Remove the given child canvas widget.  ``child``'s parent will
+        be set to None.
+
+        :type child: CanvasWidget
+        :param child: The child canvas widget to remove.
+        """
+        index = self._children.index(child)
+        del self._children[index]
+        self._remove_child_widget(child)
+        if len(self._children) > 0:
+            self.update(self._children[0])
+
+    def insert_child(self, index, child):
+        """
+        Insert a child canvas widget before a given index.
+
+        :type child: CanvasWidget
+        :param child: The canvas widget that should be inserted.
+        :type index: int
+        :param index: The index where the child widget should be
+            inserted.  In particular, the index of ``child`` will be
+            ``index``; and the index of any children whose indices were
+            greater than equal to ``index`` before ``child`` was
+            inserted will be incremented by one.
+        """
+        self._children.insert(index, child)
+        self._add_child_widget(child)
+
+
+class SpaceWidget(CanvasWidget):
+    """
+    A canvas widget that takes up space but does not display
+    anything.  A ``SpaceWidget`` can be used to add space between
+    elements.  Each space widget is characterized by a width and a
+    height.  If you wish to only create horizontal space, then use a
+    height of zero; and if you wish to only create vertical space, use
+    a width of zero.
+    """
+
+    def __init__(self, canvas, width, height, **attribs):
+        """
+        Create a new space widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :type width: int
+        :param width: The width of the new space widget.
+        :type height: int
+        :param height: The height of the new space widget.
+        :param attribs: The new canvas widget's attributes.
+        """
+        # For some reason,
+        if width > 4:
+            width -= 4
+        if height > 4:
+            height -= 4
+        self._tag = canvas.create_line(1, 1, width, height, fill="")
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    # note: width() and height() are already defined by CanvasWidget.
+    def set_width(self, width):
+        """
+        Change the width of this space widget.
+
+        :param width: The new width.
+        :type width: int
+        :rtype: None
+        """
+        [x1, y1, x2, y2] = self.bbox()
+        self.canvas().coords(self._tag, x1, y1, x1 + width, y2)
+
+    def set_height(self, height):
+        """
+        Change the height of this space widget.
+
+        :param height: The new height.
+        :type height: int
+        :rtype: None
+        """
+        [x1, y1, x2, y2] = self.bbox()
+        self.canvas().coords(self._tag, x1, y1, x2, y1 + height)
+
+    def _tags(self):
+        return [self._tag]
+
+    def __repr__(self):
+        return "[Space]"
+
+
+class ScrollWatcherWidget(CanvasWidget):
+    """
+    A special canvas widget that adjusts its ``Canvas``'s scrollregion
+    to always include the bounding boxes of all of its children.  The
+    scroll-watcher widget will only increase the size of the
+    ``Canvas``'s scrollregion; it will never decrease it.
+    """
+
+    def __init__(self, canvas, *children, **attribs):
+        """
+        Create a new scroll-watcher widget.
+
+        :type canvas: Tkinter.Canvas
+        :param canvas: This canvas widget's canvas.
+        :type children: list(CanvasWidget)
+        :param children: The canvas widgets watched by the
+            scroll-watcher.  The scroll-watcher will ensure that these
+            canvas widgets are always contained in their canvas's
+            scrollregion.
+        :param attribs: The new canvas widget's attributes.
+        """
+        for child in children:
+            self._add_child_widget(child)
+        CanvasWidget.__init__(self, canvas, **attribs)
+
+    def add_child(self, canvaswidget):
+        """
+        Add a new canvas widget to the scroll-watcher.  The
+        scroll-watcher will ensure that the new canvas widget is
+        always contained in its canvas's scrollregion.
+
+        :param canvaswidget: The new canvas widget.
+        :type canvaswidget: CanvasWidget
+        :rtype: None
+        """
+        self._add_child_widget(canvaswidget)
+        self.update(canvaswidget)
+
+    def remove_child(self, canvaswidget):
+        """
+        Remove a canvas widget from the scroll-watcher.  The
+        scroll-watcher will no longer ensure that the new canvas
+        widget is always contained in its canvas's scrollregion.
+
+        :param canvaswidget: The canvas widget to remove.
+        :type canvaswidget: CanvasWidget
+        :rtype: None
+        """
+        self._remove_child_widget(canvaswidget)
+
+    def _tags(self):
+        return []
+
+    def _update(self, child):
+        self._adjust_scrollregion()
+
+    def _adjust_scrollregion(self):
+        """
+        Adjust the scrollregion of this scroll-watcher's ``Canvas`` to
+        include the bounding boxes of all of its children.
+        """
+        bbox = self.bbox()
+        canvas = self.canvas()
+        scrollregion = [int(n) for n in canvas["scrollregion"].split()]
+        if len(scrollregion) != 4:
+            return
+        if (
+            bbox[0] < scrollregion[0]
+            or bbox[1] < scrollregion[1]
+            or bbox[2] > scrollregion[2]
+            or bbox[3] > scrollregion[3]
+        ):
+            scrollregion = "%d %d %d %d" % (
+                min(bbox[0], scrollregion[0]),
+                min(bbox[1], scrollregion[1]),
+                max(bbox[2], scrollregion[2]),
+                max(bbox[3], scrollregion[3]),
+            )
+            canvas["scrollregion"] = scrollregion
+
+
+##//////////////////////////////////////////////////////
+##  Canvas Frame
+##//////////////////////////////////////////////////////
+
+
+class CanvasFrame:
+    """
+    A ``Tkinter`` frame containing a canvas and scrollbars.
+    ``CanvasFrame`` uses a ``ScrollWatcherWidget`` to ensure that all of
+    the canvas widgets contained on its canvas are within its
+    scrollregion.  In order for ``CanvasFrame`` to make these checks,
+    all canvas widgets must be registered with ``add_widget`` when they
+    are added to the canvas; and destroyed with ``destroy_widget`` when
+    they are no longer needed.
+
+    If a ``CanvasFrame`` is created with no parent, then it will create
+    its own main window, including a "Done" button and a "Print"
+    button.
+    """
+
+    def __init__(self, parent=None, **kw):
+        """
+        Create a new ``CanvasFrame``.
+
+        :type parent: Tkinter.BaseWidget or Tkinter.Tk
+        :param parent: The parent ``Tkinter`` widget.  If no parent is
+            specified, then ``CanvasFrame`` will create a new main
+            window.
+        :param kw: Keyword arguments for the new ``Canvas``.  See the
+            documentation for ``Tkinter.Canvas`` for more information.
+        """
+        # If no parent was given, set up a top-level window.
+        if parent is None:
+            self._parent = Tk()
+            self._parent.title("NLTK")
+            self._parent.bind("<Control-p>", lambda e: self.print_to_file())
+            self._parent.bind("<Control-x>", self.destroy)
+            self._parent.bind("<Control-q>", self.destroy)
+        else:
+            self._parent = parent
+
+        # Create a frame for the canvas & scrollbars
+        self._frame = frame = Frame(self._parent)
+        self._canvas = canvas = Canvas(frame, **kw)
+        xscrollbar = Scrollbar(self._frame, orient="horizontal")
+        yscrollbar = Scrollbar(self._frame, orient="vertical")
+        xscrollbar["command"] = canvas.xview
+        yscrollbar["command"] = canvas.yview
+        canvas["xscrollcommand"] = xscrollbar.set
+        canvas["yscrollcommand"] = yscrollbar.set
+        yscrollbar.pack(fill="y", side="right")
+        xscrollbar.pack(fill="x", side="bottom")
+        canvas.pack(expand=1, fill="both", side="left")
+
+        # Set initial scroll region.
+        scrollregion = "0 0 {} {}".format(canvas["width"], canvas["height"])
+        canvas["scrollregion"] = scrollregion
+
+        self._scrollwatcher = ScrollWatcherWidget(canvas)
+
+        # If no parent was given, pack the frame, and add a menu.
+        if parent is None:
+            self.pack(expand=1, fill="both")
+            self._init_menubar()
+
+    def _init_menubar(self):
+        menubar = Menu(self._parent)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(
+            label="Print to Postscript",
+            underline=0,
+            command=self.print_to_file,
+            accelerator="Ctrl-p",
+        )
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-x"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        self._parent.config(menu=menubar)
+
+    def print_to_file(self, filename=None):
+        """
+        Print the contents of this ``CanvasFrame`` to a postscript
+        file.  If no filename is given, then prompt the user for one.
+
+        :param filename: The name of the file to print the tree to.
+        :type filename: str
+        :rtype: None
+        """
+        if filename is None:
+            ftypes = [("Postscript files", ".ps"), ("All files", "*")]
+            filename = asksaveasfilename(filetypes=ftypes, defaultextension=".ps")
+            if not filename:
+                return
+        (x0, y0, w, h) = self.scrollregion()
+        postscript = self._canvas.postscript(
+            x=x0,
+            y=y0,
+            width=w + 2,
+            height=h + 2,
+            pagewidth=w + 2,  # points = 1/72 inch
+            pageheight=h + 2,  # points = 1/72 inch
+            pagex=0,
+            pagey=0,
+        )
+        # workaround for bug in Tk font handling
+        postscript = postscript.replace(" 0 scalefont ", " 9 scalefont ")
+        with open(filename, "wb") as f:
+            f.write(postscript.encode("utf8"))
+
+    def scrollregion(self):
+        """
+        :return: The current scroll region for the canvas managed by
+            this ``CanvasFrame``.
+        :rtype: 4-tuple of int
+        """
+        (x1, y1, x2, y2) = self._canvas["scrollregion"].split()
+        return (int(x1), int(y1), int(x2), int(y2))
+
+    def canvas(self):
+        """
+        :return: The canvas managed by this ``CanvasFrame``.
+        :rtype: Tkinter.Canvas
+        """
+        return self._canvas
+
+    def add_widget(self, canvaswidget, x=None, y=None):
+        """
+        Register a canvas widget with this ``CanvasFrame``.  The
+        ``CanvasFrame`` will ensure that this canvas widget is always
+        within the ``Canvas``'s scrollregion.  If no coordinates are
+        given for the canvas widget, then the ``CanvasFrame`` will
+        attempt to find a clear area of the canvas for it.
+
+        :type canvaswidget: CanvasWidget
+        :param canvaswidget: The new canvas widget.  ``canvaswidget``
+            must have been created on this ``CanvasFrame``'s canvas.
+        :type x: int
+        :param x: The initial x coordinate for the upper left hand
+            corner of ``canvaswidget``, in the canvas's coordinate
+            space.
+        :type y: int
+        :param y: The initial y coordinate for the upper left hand
+            corner of ``canvaswidget``, in the canvas's coordinate
+            space.
+        """
+        if x is None or y is None:
+            (x, y) = self._find_room(canvaswidget, x, y)
+
+        # Move to (x,y)
+        (x1, y1, x2, y2) = canvaswidget.bbox()
+        canvaswidget.move(x - x1, y - y1)
+
+        # Register with scrollwatcher.
+        self._scrollwatcher.add_child(canvaswidget)
+
+    def _find_room(self, widget, desired_x, desired_y):
+        """
+        Try to find a space for a given widget.
+        """
+        (left, top, right, bot) = self.scrollregion()
+        w = widget.width()
+        h = widget.height()
+
+        if w >= (right - left):
+            return (0, 0)
+        if h >= (bot - top):
+            return (0, 0)
+
+        # Move the widget out of the way, for now.
+        (x1, y1, x2, y2) = widget.bbox()
+        widget.move(left - x2 - 50, top - y2 - 50)
+
+        if desired_x is not None:
+            x = desired_x
+            for y in range(top, bot - h, int((bot - top - h) / 10)):
+                if not self._canvas.find_overlapping(
+                    x - 5, y - 5, x + w + 5, y + h + 5
+                ):
+                    return (x, y)
+
+        if desired_y is not None:
+            y = desired_y
+            for x in range(left, right - w, int((right - left - w) / 10)):
+                if not self._canvas.find_overlapping(
+                    x - 5, y - 5, x + w + 5, y + h + 5
+                ):
+                    return (x, y)
+
+        for y in range(top, bot - h, int((bot - top - h) / 10)):
+            for x in range(left, right - w, int((right - left - w) / 10)):
+                if not self._canvas.find_overlapping(
+                    x - 5, y - 5, x + w + 5, y + h + 5
+                ):
+                    return (x, y)
+        return (0, 0)
+
+    def destroy_widget(self, canvaswidget):
+        """
+        Remove a canvas widget from this ``CanvasFrame``.  This
+        deregisters the canvas widget, and destroys it.
+        """
+        self.remove_widget(canvaswidget)
+        canvaswidget.destroy()
+
+    def remove_widget(self, canvaswidget):
+        # Deregister with scrollwatcher.
+        self._scrollwatcher.remove_child(canvaswidget)
+
+    def pack(self, cnf={}, **kw):
+        """
+        Pack this ``CanvasFrame``.  See the documentation for
+        ``Tkinter.Pack`` for more information.
+        """
+        self._frame.pack(cnf, **kw)
+        # Adjust to be big enough for kids?
+
+    def destroy(self, *e):
+        """
+        Destroy this ``CanvasFrame``.  If this ``CanvasFrame`` created a
+        top-level window, then this will close that window.
+        """
+        if self._parent is None:
+            return
+        self._parent.destroy()
+        self._parent = None
+
+    def mainloop(self, *args, **kwargs):
+        """
+        Enter the Tkinter mainloop.  This function must be called if
+        this frame is created from a non-interactive program (e.g.
+        from a secript); otherwise, the frame will close as soon as
+        the script completes.
+        """
+        if in_idle():
+            return
+        self._parent.mainloop(*args, **kwargs)
+
+
+##//////////////////////////////////////////////////////
+##  Text display
+##//////////////////////////////////////////////////////
+
+
+class ShowText:
+    """
+    A ``Tkinter`` window used to display a text.  ``ShowText`` is
+    typically used by graphical tools to display help text, or similar
+    information.
+    """
+
+    def __init__(self, root, title, text, width=None, height=None, **textbox_options):
+        if width is None or height is None:
+            (width, height) = self.find_dimentions(text, width, height)
+
+        # Create the main window.
+        if root is None:
+            self._top = top = Tk()
+        else:
+            self._top = top = Toplevel(root)
+        top.title(title)
+
+        b = Button(top, text="Ok", command=self.destroy)
+        b.pack(side="bottom")
+
+        tbf = Frame(top)
+        tbf.pack(expand=1, fill="both")
+        scrollbar = Scrollbar(tbf, orient="vertical")
+        scrollbar.pack(side="right", fill="y")
+        textbox = Text(tbf, wrap="word", width=width, height=height, **textbox_options)
+        textbox.insert("end", text)
+        textbox["state"] = "disabled"
+        textbox.pack(side="left", expand=1, fill="both")
+        scrollbar["command"] = textbox.yview
+        textbox["yscrollcommand"] = scrollbar.set
+
+        # Make it easy to close the window.
+        top.bind("q", self.destroy)
+        top.bind("x", self.destroy)
+        top.bind("c", self.destroy)
+        top.bind("<Return>", self.destroy)
+        top.bind("<Escape>", self.destroy)
+
+        # Focus the scrollbar, so they can use up/down, etc.
+        scrollbar.focus()
+
+    def find_dimentions(self, text, width, height):
+        lines = text.split("\n")
+        if width is None:
+            maxwidth = max(len(line) for line in lines)
+            width = min(maxwidth, 80)
+
+        # Now, find height.
+        height = 0
+        for line in lines:
+            while len(line) > width:
+                brk = line[:width].rfind(" ")
+                line = line[brk:]
+                height += 1
+            height += 1
+        height = min(height, 25)
+
+        return (width, height)
+
+    def destroy(self, *e):
+        if self._top is None:
+            return
+        self._top.destroy()
+        self._top = None
+
+    def mainloop(self, *args, **kwargs):
+        """
+        Enter the Tkinter mainloop.  This function must be called if
+        this window is created from a non-interactive program (e.g.
+        from a secript); otherwise, the window will close as soon as
+        the script completes.
+        """
+        if in_idle():
+            return
+        self._top.mainloop(*args, **kwargs)
+
+
+##//////////////////////////////////////////////////////
+##  Entry dialog
+##//////////////////////////////////////////////////////
+
+
+class EntryDialog:
+    """
+    A dialog box for entering
+    """
+
+    def __init__(
+        self, parent, original_text="", instructions="", set_callback=None, title=None
+    ):
+        self._parent = parent
+        self._original_text = original_text
+        self._set_callback = set_callback
+
+        width = int(max(30, len(original_text) * 3 / 2))
+        self._top = Toplevel(parent)
+
+        if title:
+            self._top.title(title)
+
+        # The text entry box.
+        entryframe = Frame(self._top)
+        entryframe.pack(expand=1, fill="both", padx=5, pady=5, ipady=10)
+        if instructions:
+            l = Label(entryframe, text=instructions)
+            l.pack(side="top", anchor="w", padx=30)
+        self._entry = Entry(entryframe, width=width)
+        self._entry.pack(expand=1, fill="x", padx=30)
+        self._entry.insert(0, original_text)
+
+        # A divider
+        divider = Frame(self._top, borderwidth=1, relief="sunken")
+        divider.pack(fill="x", ipady=1, padx=10)
+
+        # The buttons.
+        buttons = Frame(self._top)
+        buttons.pack(expand=0, fill="x", padx=5, pady=5)
+        b = Button(buttons, text="Cancel", command=self._cancel, width=8)
+        b.pack(side="right", padx=5)
+        b = Button(buttons, text="Ok", command=self._ok, width=8, default="active")
+        b.pack(side="left", padx=5)
+        b = Button(buttons, text="Apply", command=self._apply, width=8)
+        b.pack(side="left")
+
+        self._top.bind("<Return>", self._ok)
+        self._top.bind("<Control-q>", self._cancel)
+        self._top.bind("<Escape>", self._cancel)
+
+        self._entry.focus()
+
+    def _reset(self, *e):
+        self._entry.delete(0, "end")
+        self._entry.insert(0, self._original_text)
+        if self._set_callback:
+            self._set_callback(self._original_text)
+
+    def _cancel(self, *e):
+        try:
+            self._reset()
+        except:
+            pass
+        self._destroy()
+
+    def _ok(self, *e):
+        self._apply()
+        self._destroy()
+
+    def _apply(self, *e):
+        if self._set_callback:
+            self._set_callback(self._entry.get())
+
+    def _destroy(self, *e):
+        if self._top is None:
+            return
+        self._top.destroy()
+        self._top = None
+
+
+##//////////////////////////////////////////////////////
+##  Colorized List
+##//////////////////////////////////////////////////////
+
+
+class ColorizedList:
+    """
+    An abstract base class for displaying a colorized list of items.
+    Subclasses should define:
+
+    - ``_init_colortags``, which sets up Text color tags that
+      will be used by the list.
+    - ``_item_repr``, which returns a list of (text,colortag)
+      tuples that make up the colorized representation of the
+      item.
+
+    :note: Typically, you will want to register a callback for
+        ``'select'`` that calls ``mark`` on the given item.
+    """
+
+    def __init__(self, parent, items=[], **options):
+        """
+        Construct a new list.
+
+        :param parent: The Tk widget that contains the colorized list
+        :param items: The initial contents of the colorized list.
+        :param options:
+        """
+        self._parent = parent
+        self._callbacks = {}
+
+        # Which items are marked?
+        self._marks = {}
+
+        # Initialize the Tkinter frames.
+        self._init_itemframe(options.copy())
+
+        # Set up key & mouse bindings.
+        self._textwidget.bind("<KeyPress>", self._keypress)
+        self._textwidget.bind("<ButtonPress>", self._buttonpress)
+
+        # Fill in the given CFG's items.
+        self._items = None
+        self.set(items)
+
+    # ////////////////////////////////////////////////////////////
+    # Abstract methods
+    # ////////////////////////////////////////////////////////////
+    @abstractmethod
+    def _init_colortags(self, textwidget, options):
+        """
+        Set up any colortags that will be used by this colorized list.
+        E.g.:
+            textwidget.tag_config('terminal', foreground='black')
+        """
+
+    @abstractmethod
+    def _item_repr(self, item):
+        """
+        Return a list of (text, colortag) tuples that make up the
+        colorized representation of the item.  Colorized
+        representations may not span multiple lines.  I.e., the text
+        strings returned may not contain newline characters.
+        """
+
+    # ////////////////////////////////////////////////////////////
+    # Item Access
+    # ////////////////////////////////////////////////////////////
+
+    def get(self, index=None):
+        """
+        :return: A list of the items contained by this list.
+        """
+        if index is None:
+            return self._items[:]
+        else:
+            return self._items[index]
+
+    def set(self, items):
+        """
+        Modify the list of items contained by this list.
+        """
+        items = list(items)
+        if self._items == items:
+            return
+        self._items = list(items)
+
+        self._textwidget["state"] = "normal"
+        self._textwidget.delete("1.0", "end")
+        for item in items:
+            for (text, colortag) in self._item_repr(item):
+                assert "\n" not in text, "item repr may not contain newline"
+                self._textwidget.insert("end", text, colortag)
+            self._textwidget.insert("end", "\n")
+        # Remove the final newline
+        self._textwidget.delete("end-1char", "end")
+        self._textwidget.mark_set("insert", "1.0")
+        self._textwidget["state"] = "disabled"
+        # Clear all marks
+        self._marks.clear()
+
+    def unmark(self, item=None):
+        """
+        Remove highlighting from the given item; or from every item,
+        if no item is given.
+        :raise ValueError: If ``item`` is not contained in the list.
+        :raise KeyError: If ``item`` is not marked.
+        """
+        if item is None:
+            self._marks.clear()
+            self._textwidget.tag_remove("highlight", "1.0", "end+1char")
+        else:
+            index = self._items.index(item)
+            del self._marks[item]
+            (start, end) = ("%d.0" % (index + 1), "%d.0" % (index + 2))
+            self._textwidget.tag_remove("highlight", start, end)
+
+    def mark(self, item):
+        """
+        Highlight the given item.
+        :raise ValueError: If ``item`` is not contained in the list.
+        """
+        self._marks[item] = 1
+        index = self._items.index(item)
+        (start, end) = ("%d.0" % (index + 1), "%d.0" % (index + 2))
+        self._textwidget.tag_add("highlight", start, end)
+
+    def markonly(self, item):
+        """
+        Remove any current highlighting, and mark the given item.
+        :raise ValueError: If ``item`` is not contained in the list.
+        """
+        self.unmark()
+        self.mark(item)
+
+    def view(self, item):
+        """
+        Adjust the view such that the given item is visible.  If
+        the item is already visible, then do nothing.
+        """
+        index = self._items.index(item)
+        self._textwidget.see("%d.0" % (index + 1))
+
+    # ////////////////////////////////////////////////////////////
+    # Callbacks
+    # ////////////////////////////////////////////////////////////
+
+    def add_callback(self, event, func):
+        """
+        Register a callback function with the list.  This function
+        will be called whenever the given event occurs.
+
+        :param event: The event that will trigger the callback
+            function.  Valid events are: click1, click2, click3,
+            space, return, select, up, down, next, prior, move
+        :param func: The function that should be called when
+            the event occurs.  ``func`` will be called with a
+            single item as its argument.  (The item selected
+            or the item moved to).
+        """
+        if event == "select":
+            events = ["click1", "space", "return"]
+        elif event == "move":
+            events = ["up", "down", "next", "prior"]
+        else:
+            events = [event]
+
+        for e in events:
+            self._callbacks.setdefault(e, {})[func] = 1
+
+    def remove_callback(self, event, func=None):
+        """
+        Deregister a callback function.  If ``func`` is none, then
+        all callbacks are removed for the given event.
+        """
+        if event is None:
+            events = list(self._callbacks.keys())
+        elif event == "select":
+            events = ["click1", "space", "return"]
+        elif event == "move":
+            events = ["up", "down", "next", "prior"]
+        else:
+            events = [event]
+
+        for e in events:
+            if func is None:
+                del self._callbacks[e]
+            else:
+                try:
+                    del self._callbacks[e][func]
+                except:
+                    pass
+
+    # ////////////////////////////////////////////////////////////
+    # Tkinter Methods
+    # ////////////////////////////////////////////////////////////
+
+    def pack(self, cnf={}, **kw):
+        #        "@include: Tkinter.Pack.pack"
+        self._itemframe.pack(cnf, **kw)
+
+    def grid(self, cnf={}, **kw):
+        #        "@include: Tkinter.Grid.grid"
+        self._itemframe.grid(cnf, *kw)
+
+    def focus(self):
+        #        "@include: Tkinter.Widget.focus"
+        self._textwidget.focus()
+
+    # ////////////////////////////////////////////////////////////
+    # Internal Methods
+    # ////////////////////////////////////////////////////////////
+
+    def _init_itemframe(self, options):
+        self._itemframe = Frame(self._parent)
+
+        # Create the basic Text widget & scrollbar.
+        options.setdefault("background", "#e0e0e0")
+        self._textwidget = Text(self._itemframe, **options)
+        self._textscroll = Scrollbar(self._itemframe, takefocus=0, orient="vertical")
+        self._textwidget.config(yscrollcommand=self._textscroll.set)
+        self._textscroll.config(command=self._textwidget.yview)
+        self._textscroll.pack(side="right", fill="y")
+        self._textwidget.pack(expand=1, fill="both", side="left")
+
+        # Initialize the colorization tags
+        self._textwidget.tag_config(
+            "highlight", background="#e0ffff", border="1", relief="raised"
+        )
+        self._init_colortags(self._textwidget, options)
+
+        # How do I want to mark keyboard selection?
+        self._textwidget.tag_config("sel", foreground="")
+        self._textwidget.tag_config(
+            "sel", foreground="", background="", border="", underline=1
+        )
+        self._textwidget.tag_lower("highlight", "sel")
+
+    def _fire_callback(self, event, itemnum):
+        if event not in self._callbacks:
+            return
+        if 0 <= itemnum < len(self._items):
+            item = self._items[itemnum]
+        else:
+            item = None
+        for cb_func in list(self._callbacks[event].keys()):
+            cb_func(item)
+
+    def _buttonpress(self, event):
+        clickloc = "@%d,%d" % (event.x, event.y)
+        insert_point = self._textwidget.index(clickloc)
+        itemnum = int(insert_point.split(".")[0]) - 1
+        self._fire_callback("click%d" % event.num, itemnum)
+
+    def _keypress(self, event):
+        if event.keysym == "Return" or event.keysym == "space":
+            insert_point = self._textwidget.index("insert")
+            itemnum = int(insert_point.split(".")[0]) - 1
+            self._fire_callback(event.keysym.lower(), itemnum)
+            return
+        elif event.keysym == "Down":
+            delta = "+1line"
+        elif event.keysym == "Up":
+            delta = "-1line"
+        elif event.keysym == "Next":
+            delta = "+10lines"
+        elif event.keysym == "Prior":
+            delta = "-10lines"
+        else:
+            return "continue"
+
+        self._textwidget.mark_set("insert", "insert" + delta)
+        self._textwidget.see("insert")
+        self._textwidget.tag_remove("sel", "1.0", "end+1char")
+        self._textwidget.tag_add("sel", "insert linestart", "insert lineend")
+
+        insert_point = self._textwidget.index("insert")
+        itemnum = int(insert_point.split(".")[0]) - 1
+        self._fire_callback(event.keysym.lower(), itemnum)
+
+        return "break"
+
+
+##//////////////////////////////////////////////////////
+##  Improved OptionMenu
+##//////////////////////////////////////////////////////
+
+
+class MutableOptionMenu(Menubutton):
+    def __init__(self, master, values, **options):
+        self._callback = options.get("command")
+        if "command" in options:
+            del options["command"]
+
+        # Create a variable
+        self._variable = variable = StringVar()
+        if len(values) > 0:
+            variable.set(values[0])
+
+        kw = {
+            "borderwidth": 2,
+            "textvariable": variable,
+            "indicatoron": 1,
+            "relief": RAISED,
+            "anchor": "c",
+            "highlightthickness": 2,
+        }
+        kw.update(options)
+        Widget.__init__(self, master, "menubutton", kw)
+        self.widgetName = "tk_optionMenu"
+        self._menu = Menu(self, name="menu", tearoff=0)
+        self.menuname = self._menu._w
+
+        self._values = []
+        for value in values:
+            self.add(value)
+
+        self["menu"] = self._menu
+
+    def add(self, value):
+        if value in self._values:
+            return
+
+        def set(value=value):
+            self.set(value)
+
+        self._menu.add_command(label=value, command=set)
+        self._values.append(value)
+
+    def set(self, value):
+        self._variable.set(value)
+        if self._callback:
+            self._callback(value)
+
+    def remove(self, value):
+        # Might raise indexerror: pass to parent.
+        i = self._values.index(value)
+        del self._values[i]
+        self._menu.delete(i, i)
+
+    def __getitem__(self, name):
+        if name == "menu":
+            return self.__menu
+        return Widget.__getitem__(self, name)
+
+    def destroy(self):
+        """Destroy this widget and the associated menu."""
+        Menubutton.destroy(self)
+        self._menu = None
+
+
+##//////////////////////////////////////////////////////
+##  Test code.
+##//////////////////////////////////////////////////////
+
+
+def demo():
+    """
+    A simple demonstration showing how to use canvas widgets.
+    """
+
+    def fill(cw):
+        from random import randint
+
+        cw["fill"] = "#00%04d" % randint(0, 9999)
+
+    def color(cw):
+        from random import randint
+
+        cw["color"] = "#ff%04d" % randint(0, 9999)
+
+    cf = CanvasFrame(closeenough=10, width=300, height=300)
+    c = cf.canvas()
+    ct3 = TextWidget(c, "hiya there", draggable=1)
+    ct2 = TextWidget(c, "o  o\n||\n___\n  U", draggable=1, justify="center")
+    co = OvalWidget(c, ct2, outline="red")
+    ct = TextWidget(c, "o  o\n||\n\\___/", draggable=1, justify="center")
+    cp = ParenWidget(c, ct, color="red")
+    cb = BoxWidget(c, cp, fill="cyan", draggable=1, width=3, margin=10)
+    equation = SequenceWidget(
+        c,
+        SymbolWidget(c, "forall"),
+        TextWidget(c, "x"),
+        SymbolWidget(c, "exists"),
+        TextWidget(c, "y: "),
+        TextWidget(c, "x"),
+        SymbolWidget(c, "notequal"),
+        TextWidget(c, "y"),
+    )
+    space = SpaceWidget(c, 0, 30)
+    cstack = StackWidget(c, cb, ct3, space, co, equation, align="center")
+    prompt_msg = TextWidget(
+        c, "try clicking\nand dragging", draggable=1, justify="center"
+    )
+    cs = SequenceWidget(c, cstack, prompt_msg)
+    zz = BracketWidget(c, cs, color="green4", width=3)
+    cf.add_widget(zz, 60, 30)
+
+    cb.bind_click(fill)
+    ct.bind_click(color)
+    co.bind_click(fill)
+    ct2.bind_click(color)
+    ct3.bind_click(color)
+
+    cf.mainloop()
+    # ShowText(None, 'title', ((('this is text'*150)+'\n')*5))
+
+
+if __name__ == "__main__":
+    demo()

env-llmeval/lib/python3.10/site-packages/nltk/lm/smoothing.py

@@ -0,0 +1,127 @@
+# Natural Language Toolkit: Language Model Unit Tests
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ilia Kurenkov <[email protected]>
+#         Manu Joseph <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+"""Smoothing algorithms for language modeling.
+
+According to Chen & Goodman 1995 these should work with both Backoff and
+Interpolation.
+"""
+from operator import methodcaller
+
+from nltk.lm.api import Smoothing
+from nltk.probability import ConditionalFreqDist
+
+
+def _count_values_gt_zero(distribution):
+    """Count values that are greater than zero in a distribution.
+
+    Assumes distribution is either a mapping with counts as values or
+    an instance of `nltk.ConditionalFreqDist`.
+    """
+    as_count = (
+        methodcaller("N")
+        if isinstance(distribution, ConditionalFreqDist)
+        else lambda count: count
+    )
+    # We explicitly check that values are > 0 to guard against negative counts.
+    return sum(
+        1 for dist_or_count in distribution.values() if as_count(dist_or_count) > 0
+    )
+
+
+class WittenBell(Smoothing):
+    """Witten-Bell smoothing."""
+
+    def __init__(self, vocabulary, counter, **kwargs):
+        super().__init__(vocabulary, counter, **kwargs)
+
+    def alpha_gamma(self, word, context):
+        alpha = self.counts[context].freq(word)
+        gamma = self._gamma(context)
+        return (1.0 - gamma) * alpha, gamma
+
+    def _gamma(self, context):
+        n_plus = _count_values_gt_zero(self.counts[context])
+        return n_plus / (n_plus + self.counts[context].N())
+
+    def unigram_score(self, word):
+        return self.counts.unigrams.freq(word)
+
+
+class AbsoluteDiscounting(Smoothing):
+    """Smoothing with absolute discount."""
+
+    def __init__(self, vocabulary, counter, discount=0.75, **kwargs):
+        super().__init__(vocabulary, counter, **kwargs)
+        self.discount = discount
+
+    def alpha_gamma(self, word, context):
+        alpha = (
+            max(self.counts[context][word] - self.discount, 0)
+            / self.counts[context].N()
+        )
+        gamma = self._gamma(context)
+        return alpha, gamma
+
+    def _gamma(self, context):
+        n_plus = _count_values_gt_zero(self.counts[context])
+        return (self.discount * n_plus) / self.counts[context].N()
+
+    def unigram_score(self, word):
+        return self.counts.unigrams.freq(word)
+
+
+class KneserNey(Smoothing):
+    """Kneser-Ney Smoothing.
+
+    This is an extension of smoothing with a discount.
+
+    Resources:
+    - https://pages.ucsd.edu/~rlevy/lign256/winter2008/kneser_ney_mini_example.pdf
+    - https://www.youtube.com/watch?v=ody1ysUTD7o
+    - https://medium.com/@dennyc/a-simple-numerical-example-for-kneser-ney-smoothing-nlp-4600addf38b8
+    - https://www.cl.uni-heidelberg.de/courses/ss15/smt/scribe6.pdf
+    - https://www-i6.informatik.rwth-aachen.de/publications/download/951/Kneser-ICASSP-1995.pdf
+    """
+
+    def __init__(self, vocabulary, counter, order, discount=0.1, **kwargs):
+        super().__init__(vocabulary, counter, **kwargs)
+        self.discount = discount
+        self._order = order
+
+    def unigram_score(self, word):
+        word_continuation_count, total_count = self._continuation_counts(word)
+        return word_continuation_count / total_count
+
+    def alpha_gamma(self, word, context):
+        prefix_counts = self.counts[context]
+        word_continuation_count, total_count = (
+            (prefix_counts[word], prefix_counts.N())
+            if len(context) + 1 == self._order
+            else self._continuation_counts(word, context)
+        )
+        alpha = max(word_continuation_count - self.discount, 0.0) / total_count
+        gamma = self.discount * _count_values_gt_zero(prefix_counts) / total_count
+        return alpha, gamma
+
+    def _continuation_counts(self, word, context=tuple()):
+        """Count continuations that end with context and word.
+
+        Continuations track unique ngram "types", regardless of how many
+        instances were observed for each "type".
+        This is different than raw ngram counts which track number of instances.
+        """
+        higher_order_ngrams_with_context = (
+            counts
+            for prefix_ngram, counts in self.counts[len(context) + 2].items()
+            if prefix_ngram[1:] == context
+        )
+        higher_order_ngrams_with_word_count, total = 0, 0
+        for counts in higher_order_ngrams_with_context:
+            higher_order_ngrams_with_word_count += int(counts[word] > 0)
+            total += _count_values_gt_zero(counts)
+        return higher_order_ngrams_with_word_count, total