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