Merge pull request #676 from stevenbird/issue/657

Names for grammar classes

nltk/app/chartparser_app.py

@@ -51,7 +51,7 @@ from nltk.parse.chart import (BottomUpPredictCombineRule, BottomUpPredictRule,
                               SteppingChartParser, TopDownInitRule, TopDownPredictRule,
                               TreeEdge)
 from nltk.tree import Tree
-from nltk.grammar import Nonterminal, ContextFreeGrammar
+from nltk.grammar import Nonterminal, CFG
 from nltk.util import in_idle
 from nltk.draw.util import (CanvasFrame, ColorizedList,
                             EntryDialog, MutableOptionMenu,
@@ -2038,7 +2038,7 @@ class ChartParserApp(object):
                     grammar = pickle.load(infile)
             else:
                 with open(filename, 'r') as infile:
-                    grammar = ContextFreeGrammar.fromstring(infile.read())
+                    grammar = CFG.fromstring(infile.read())
             self.set_grammar(grammar)
         except Exception as e:
             tkinter.messagebox.showerror('Error Loading Grammar',
@@ -2230,7 +2230,7 @@ class ChartParserApp(object):
         self.apply_strategy(self._TD_STRATEGY, TopDownPredictEdgeRule)
 
 def app():
-    grammar = ContextFreeGrammar.fromstring("""
+    grammar = CFG.fromstring("""
     # Grammatical productions.
         S -> NP VP
         VP -> VP PP | V NP | V

nltk/app/rdparser_app.py

@@ -867,8 +867,8 @@ def app():
     Create a recursive descent parser demo, using a simple grammar and
     text.
     """
-    from nltk.grammar import ContextFreeGrammar
-    grammar = ContextFreeGrammar.fromstring("""
+    from nltk.grammar import CFG
+    grammar = CFG.fromstring("""
     # Grammatical productions.
         S -> NP VP
         NP -> Det N PP | Det N

nltk/app/srparser_app.py

@@ -772,7 +772,7 @@ def app():
     text.
     """
 
-    from nltk.grammar import Nonterminal, Production, ContextFreeGrammar
+    from nltk.grammar import Nonterminal, Production, CFG
     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()]
@@ -796,7 +796,7 @@ def app():
         Production(Det, ['my']),
         )
 
-    grammar = ContextFreeGrammar(S, productions)
+    grammar = CFG(S, productions)
 
     # tokenize the sentence
     sent = 'my dog saw a man in the park with a statue'.split()

nltk/data.py

@@ -803,10 +803,10 @@ def load(resource_url, format='auto', cache=True, verbose=False,
         if format == 'text':
             resource_val = string_data
         elif format == 'cfg':
-            resource_val = nltk.grammar.ContextFreeGrammar.fromstring(
+            resource_val = nltk.grammar.CFG.fromstring(
                 string_data, encoding=encoding)
         elif format == 'pcfg':
-            resource_val = nltk.grammar.WeightedGrammar.fromstring(
+            resource_val = nltk.grammar.PCFG.fromstring(
                 string_data, encoding=encoding)
         elif format == 'fcfg':
             resource_val = nltk.grammar.FeatureGrammar.fromstring(

nltk/draw/cfg.py

@@ -54,7 +54,7 @@ import re
 from tkinter import (Button, Canvas, Entry, Frame, IntVar, Label,
                      Scrollbar, Text, Tk, Toplevel)
 
-from nltk.grammar import (ContextFreeGrammar, _read_cfg_production,
+from nltk.grammar import (CFG, _read_cfg_production,
                           Nonterminal, nonterminals)
 from nltk.tree import Tree
 from nltk.draw.tree import TreeSegmentWidget, tree_to_treesegment
@@ -157,7 +157,7 @@ class CFGEditor(object):
     def __init__(self, parent, cfg=None, set_cfg_callback=None):
         self._parent = parent
         if cfg is not None: self._cfg = cfg
-        else: self._cfg = ContextFreeGrammar(Nonterminal('S'), [])
+        else: self._cfg = CFG(Nonterminal('S'), [])
         self._set_cfg_callback = set_cfg_callback
 
         self._highlight_matching_nonterminals = 1
@@ -482,7 +482,7 @@ class CFGEditor(object):
     def _apply(self, *e):
         productions = self._parse_productions()
         start = Nonterminal(self._start.get())
-        cfg = ContextFreeGrammar(start, productions)
+        cfg = CFG(start, productions)
         if self._set_cfg_callback is not None:
             self._set_cfg_callback(cfg)
 
@@ -666,7 +666,7 @@ class CFGDemo(object):
         self._top.mainloop(*args, **kwargs)
 
 def demo2():
-    from nltk import Nonterminal, Production, ContextFreeGrammar
+    from nltk import Nonterminal, Production, CFG
     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()]
@@ -691,7 +691,7 @@ def demo2():
         Production(N, ['dog']),  Production(N, ['statue']),
         Production(Det, ['my']),
         )
-    grammar = ContextFreeGrammar(S, productions)
+    grammar = CFG(S, productions)
 
     text = 'I saw a man in the park'.split()
     d=CFGDemo(grammar, text)
@@ -702,12 +702,12 @@ def demo2():
 ######################################################################
 
 def demo():
-    from nltk import Nonterminal, ContextFreeGrammar
+    from nltk import Nonterminal, CFG
     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 = ContextFreeGrammar.fromstring("""
+    grammar = CFG.fromstring("""
     S -> NP VP
     PP -> P NP
     NP -> Det N

nltk/parse/chart.py

@@ -43,7 +43,7 @@ import warnings
 
 from nltk import compat
 from nltk.tree import Tree
-from nltk.grammar import WeightedGrammar, is_nonterminal, is_terminal
+from nltk.grammar import PCFG, is_nonterminal, is_terminal
 from nltk.util import OrderedDict
 from nltk.internals import raise_unorderable_types
 from nltk.compat import (total_ordering, python_2_unicode_compatible,
@@ -1242,7 +1242,7 @@ class ChartParser(ParserI):
         Create a new chart parser, that uses ``grammar`` to parse
         texts.
 
-        :type grammar: ContextFreeGrammar
+        :type grammar: CFG
         :param grammar: The grammar used to parse texts.
         :type strategy: list(ChartRuleI)
         :param strategy: A list of rules that should be used to decide
@@ -1364,8 +1364,8 @@ class BottomUpChartParser(ChartParser):
     See ``ChartParser`` for more information.
     """
     def __init__(self, grammar, **parser_args):
-        if isinstance(grammar, WeightedGrammar):
-            warnings.warn("BottomUpChartParser only works for ContextFreeGrammar, "
+        if isinstance(grammar, PCFG):
+            warnings.warn("BottomUpChartParser only works for CFG, "
                           "use BottomUpProbabilisticChartParser instead",
                           category=DeprecationWarning)
         ChartParser.__init__(self, grammar, BU_STRATEGY, **parser_args)
@@ -1548,8 +1548,8 @@ class SteppingChartParser(ChartParser):
 ########################################################################
 
 def demo_grammar():
-    from nltk.grammar import ContextFreeGrammar
-    return ContextFreeGrammar.fromstring("""
+    from nltk.grammar import CFG
+    return CFG.fromstring("""
 S  -> NP VP
 PP -> "with" NP
 NP -> NP PP
@@ -1578,7 +1578,7 @@ def demo(choice=None,
     A demonstration of the chart parsers.
     """
     import sys, time
-    from nltk import nonterminals, Production, ContextFreeGrammar
+    from nltk import nonterminals, Production, CFG
 
     # The grammar for ChartParser and SteppingChartParser:
     grammar = demo_grammar()

nltk/parse/earleychart.py

@@ -268,7 +268,7 @@ class IncrementalChartParser(ChartParser):
         Create a new Earley chart parser, that uses ``grammar`` to
         parse texts.
 
-        :type grammar: ContextFreeGrammar
+        :type grammar: CFG
         :param grammar: The grammar used to parse texts.
         :type trace: int
         :param trace: The level of tracing that should be used when

nltk/parse/featurechart.py

@@ -17,7 +17,7 @@ from nltk.compat import xrange, python_2_unicode_compatible
 from nltk.featstruct import FeatStruct, unify, TYPE, find_variables
 from nltk.sem import logic
 from nltk.tree import Tree
-from nltk.grammar import (Nonterminal, Production, ContextFreeGrammar,
+from nltk.grammar import (Nonterminal, Production, CFG,
                           FeatStructNonterminal, is_nonterminal,
                           is_terminal)
 from nltk.parse.chart import (TreeEdge, Chart, ChartParser, EdgeI,

nltk/parse/generate.py

@@ -64,11 +64,11 @@ demo_grammar = """
 """
 
 def demo(N=23):
-    from nltk.grammar import ContextFreeGrammar
+    from nltk.grammar import CFG
 
     print('Generating the first %d sentences for demo grammar:' % (N,))
     print(demo_grammar)
-    grammar = ContextFreeGrammar.fromstring(demo_grammar)
+    grammar = CFG.fromstring(demo_grammar)
     for n, sent in enumerate(generate(grammar, n=N), 1):
         print('%3d. %s' % (n, ' '.join(sent)))
 

nltk/parse/pchart.py

@@ -40,7 +40,7 @@ from __future__ import print_function, unicode_literals
 
 from functools import reduce
 from nltk.tree import Tree, ProbabilisticTree
-from nltk.grammar import Nonterminal, WeightedGrammar
+from nltk.grammar import Nonterminal, PCFG
 
 from nltk.parse.api import ParserI
 from nltk.parse.chart import Chart, LeafEdge, TreeEdge, AbstractChartRule
@@ -173,8 +173,8 @@ class BottomUpProbabilisticChartParser(ParserI):
             and higher numbers will produce more verbose tracing
             output.
         """
-        if not isinstance(grammar, WeightedGrammar):
-            raise ValueError("The grammar must be probabilistic WeightedGrammar")
+        if not isinstance(grammar, PCFG):
+            raise ValueError("The grammar must be probabilistic PCFG")
         self._grammar = grammar
         self.beam_size = beam_size
         self._trace = trace

nltk/parse/projectivedependencyparser.py

@@ -11,7 +11,7 @@ from __future__ import print_function, unicode_literals
 from collections import defaultdict
 
 from nltk.grammar import (DependencyProduction, DependencyGrammar,
-                          StatisticalDependencyGrammar)
+                          ProbabilisticDependencyGrammar)
 from nltk.parse.dependencygraph import DependencyGraph, conll_data2
 from nltk.internals import raise_unorderable_types
 from nltk.compat import total_ordering, python_2_unicode_compatible
@@ -334,7 +334,7 @@ class ProbabilisticProjectiveDependencyParser(object):
 
     def train(self, graphs):
         """
-        Trains a StatisticalDependencyGrammar based on the list of input
+        Trains a ProbabilisticDependencyGrammar based on the list of input
         DependencyGraphs.  This model is an implementation of Eisner's (1996)
         Model C, which derives its statistics from head-word, head-tag,
         child-word, and child-tag relationships.
@@ -390,7 +390,7 @@ class ProbabilisticProjectiveDependencyParser(object):
                         mod_event = '(mods (%s, %s, %s) right))' % (prev_tag, head_word, head_tag)
                         events[head_event] += 1
                         events[mod_event] += 1
-        self._grammar = StatisticalDependencyGrammar(productions, events, tags)
+        self._grammar = ProbabilisticDependencyGrammar(productions, events, tags)
 #        print self._grammar
 
     def compute_prob(self, dg):

nltk/parse/recursivedescent.py

@@ -56,7 +56,7 @@ class RecursiveDescentParser(ParserI):
         Create a new ``RecursiveDescentParser``, that uses ``grammar``
         to parse texts.
 
-        :type grammar: ContextFreeGrammar
+        :type grammar: CFG
         :param grammar: The grammar used to parse texts.
         :type trace: int
         :param trace: The level of tracing that should be used when
@@ -630,9 +630,9 @@ def demo():
     A demonstration of the recursive descent parser.
     """
 
-    from nltk import parse, ContextFreeGrammar
+    from nltk import parse, CFG
 
-    grammar = ContextFreeGrammar.fromstring("""
+    grammar = CFG.fromstring("""
     S -> NP VP
     NP -> Det N | Det N PP
     VP -> V NP | V NP PP

nltk/parse/shiftreduce.py

@@ -435,9 +435,9 @@ def demo():
     A demonstration of the shift-reduce parser.
     """
 
-    from nltk import parse, ContextFreeGrammar
+    from nltk import parse, CFG
 
-    grammar = ContextFreeGrammar.fromstring("""
+    grammar = CFG.fromstring("""
     S -> NP VP
     NP -> Det N | Det N PP
     VP -> V NP | V NP PP

nltk/parse/util.py

@@ -12,7 +12,7 @@ Utility functions for parsers.
 """
 from __future__ import print_function
 
-from nltk.grammar import ContextFreeGrammar, FeatureGrammar, WeightedGrammar
+from nltk.grammar import CFG, FeatureGrammar, PCFG
 from nltk.data import load
 
 from nltk.parse.chart import Chart, ChartParser
@@ -28,9 +28,9 @@ def load_parser(grammar_url, trace=0,
     on properties of the grammar itself.
 
     The following grammar formats are currently supported:
-      - ``'cfg'``  (CFGs: ``ContextFreeGrammar``)
-      - ``'pcfg'`` (probabilistic CFGs: ``WeightedGrammar``)
-      - ``'fcfg'`` (feature-based CFGs: ``ContextFreeGrammar``)
+      - ``'cfg'``  (CFGs: ``CFG``)
+      - ``'pcfg'`` (probabilistic CFGs: ``PCFG``)
+      - ``'fcfg'`` (feature-based CFGs: ``CFG``)
 
     :type grammar_url: str
     :param grammar_url: A URL specifying where the grammar is located.
@@ -54,10 +54,10 @@ def load_parser(grammar_url, trace=0,
         See ``data.load`` for more information.
     """
     grammar = load(grammar_url, **load_args)
-    if not isinstance(grammar, ContextFreeGrammar):
-        raise ValueError("The grammar must be a ContextFreeGrammar, "
+    if not isinstance(grammar, CFG):
+        raise ValueError("The grammar must be a CFG, "
                          "or a subclass thereof.")
-    if isinstance(grammar, WeightedGrammar):
+    if isinstance(grammar, PCFG):
         if parser is None:
             parser = InsideChartParser
         return parser(grammar, trace=trace, beam_size=beam_size)
@@ -69,7 +69,7 @@ def load_parser(grammar_url, trace=0,
             chart_class = FeatureChart
         return parser(grammar, trace=trace, chart_class=chart_class)
 
-    else: # Plain ContextFreeGrammar.
+    else: # Plain CFG.
         if parser is None:
             parser = ChartParser
         if chart_class is None:

nltk/parse/viterbi.py

@@ -67,7 +67,7 @@ class ViterbiParser(ParserI):
     |             MLC[start, start+width, prod.lhs] = new_tree
     | Return MLC[0, len(text), start_symbol]
 
-    :type _grammar: WeightedGrammar
+    :type _grammar: PCFG
     :ivar _grammar: The grammar used to parse sentences.
     :type _trace: int
     :ivar _trace: The level of tracing output that should be generated
@@ -78,7 +78,7 @@ class ViterbiParser(ParserI):
         Create a new ``ViterbiParser`` parser, that uses ``grammar`` to
         parse texts.
 
-        :type grammar: WeightedGrammar
+        :type grammar: PCFG
         :param grammar: The grammar used to parse texts.
         :type trace: int
         :param trace: The level of tracing that should be used when

nltk/test/data.doctest

@@ -309,7 +309,7 @@ internal use by NLTK's corpus readers.
 
     >>> # Show that it's now been loaded:
     >>> object.__repr__(ll) # doctest: +ELLIPSIS
-    '<nltk.grammar.ContextFreeGrammar object at ...>'
+    '<nltk.grammar.CFG object at ...>'
 
 
     >>> # Test that accessing an attribute also loads it:
@@ -317,7 +317,7 @@ internal use by NLTK's corpus readers.
     >>> ll.start()
     S
     >>> object.__repr__(ll) # doctest: +ELLIPSIS
-    '<nltk.grammar.ContextFreeGrammar object at ...>'
+    '<nltk.grammar.CFG object at ...>'
 
 Buffered Gzip Reading and Writing
 ---------------------------------

nltk/test/generate.doctest

@@ -8,8 +8,8 @@ Generating sentences from context-free grammars
 An example grammar:
 
     >>> from nltk.parse.generate import generate, demo_grammar
-    >>> from nltk import ContextFreeGrammar
-    >>> grammar = ContextFreeGrammar.fromstring(demo_grammar)
+    >>> from nltk import CFG
+    >>> grammar = CFG.fromstring(demo_grammar)
     >>> print(grammar)
     Grammar with 13 productions (start state = S)
         S -> NP VP

nltk/test/grammar.doctest

@@ -7,8 +7,8 @@ Grammar Parsing
 
 Grammars can be parsed from strings:
 
-    >>> from nltk import ContextFreeGrammar
-    >>> grammar = ContextFreeGrammar.fromstring("""
+    >>> from nltk import CFG
+    >>> grammar = CFG.fromstring("""
     ... S -> NP VP
     ... PP -> P NP
     ... NP -> Det N | NP PP
@@ -29,8 +29,8 @@ Grammars can be parsed from strings:
 
 Probabilistic CFGs:
    
-    >>> from nltk import WeightedGrammar
-    >>> toy_pcfg1 = WeightedGrammar.fromstring("""
+    >>> from nltk import PCFG
+    >>> toy_pcfg1 = PCFG.fromstring("""
     ... S -> NP VP [1.0]
     ... NP -> Det N [0.5] | NP PP [0.25] | 'John' [0.1] | 'I' [0.15]
     ... Det -> 'the' [0.8] | 'my' [0.2]
@@ -43,6 +43,6 @@ Probabilistic CFGs:
 
 Chomsky Normal Form grammar (Test for bug 474)
 
-    >>> g = ContextFreeGrammar.fromstring("VP^<TOP> -> VBP NP^<VP-TOP>")
+    >>> g = CFG.fromstring("VP^<TOP> -> VBP NP^<VP-TOP>")
     >>> g.productions()[0].lhs()
     VP^<TOP>

nltk/test/parse.doctest

@@ -8,7 +8,7 @@
 Unit tests for the Context Free Grammar class
 ---------------------------------------------
 
-    >>> from nltk import Nonterminal, nonterminals, Production, ContextFreeGrammar
+    >>> from nltk import Nonterminal, nonterminals, Production, CFG
 
     >>> nt1 = Nonterminal('NP')
     >>> nt2 = Nonterminal('VP')
@@ -40,7 +40,7 @@ Unit tests for the Context Free Grammar class
     >>> prod1 == prod2
     False
 
-    >>> grammar = ContextFreeGrammar.fromstring("""
+    >>> grammar = CFG.fromstring("""
     ... S -> NP VP
     ... PP -> P NP
     ... NP -> 'the' N | N PP | 'the' N PP
@@ -529,11 +529,11 @@ Unit tests for the Probabilistic CFG class
 
     >>> from nltk.corpus import treebank
     >>> from itertools import islice
-    >>> from nltk.grammar import WeightedGrammar, induce_pcfg, toy_pcfg1, toy_pcfg2
+    >>> from nltk.grammar import PCFG, induce_pcfg, toy_pcfg1, toy_pcfg2
 
-Create a set of probabilistic CFG productions.
+Create a set of PCFG productions.
 
-    >>> grammar = WeightedGrammar.fromstring("""
+    >>> grammar = PCFG.fromstring("""
     ... A -> B B [.3] | C B C [.7]
     ... B -> B D [.5] | C [.5]
     ... C -> 'a' [.1] | 'b' [0.9]

nltk/test/simple.doctest

@@ -62,8 +62,8 @@ Parsing
 -------
 
     >>> from nltk.parse.recursivedescent import RecursiveDescentParser
-    >>> from nltk.grammar import ContextFreeGrammar
-    >>> grammar = ContextFreeGrammar.fromstring("""
+    >>> from nltk.grammar import CFG
+    >>> grammar = CFG.fromstring("""
     ... S -> NP VP
     ... PP -> P NP
     ... NP -> 'the' N | N PP | 'the' N PP