def __init__(self, input, gramfile=None, background=None):
"""
Initialize a C{DiscourseTester}.
@parameter input: the discourse sentences
@type input: C{list} of C{str}
@parameter gramfile: name of file where grammar can be loaded
@type gramfile: C{str}
@parameter background: Formulas which express background assumptions
@type background: C{list} of L{logic.Expression}.
"""
self._input = input
self._sentences = dict([('s%s' % i, sent)
for i, sent in enumerate(input)])
self._models = None
self._readings = {}
if gramfile is None:
self._gramfile = 'grammars/sem4.fcfg'
else:
self._gramfile = gramfile
self._threads = {}
self._filtered_threads = {}
self._parser = parse.load_earley(self._gramfile)
if background is not None:
for e in background:
assert isinstance(e, Expression)
self._background = background
else:
self._background = []
def __init__(self, input, gramfile=None, background=None):
"""
Initialize a C{DiscourseTester}.
@parameter input: the discourse sentences
@type input: C{list} of C{str}
@parameter gramfile: name of file where grammar can be loaded
@type gramfile: C{str}
@parameter background: Formulas which express background assumptions
@type background: C{list} of L{logic.Expression}.
"""
self._input = input
self._sentences = dict([('s%s' % i, sent) for i, sent in enumerate(input)])
self._models = None
self._readings = {}
if gramfile is None:
self._gramfile = 'grammars/sem4.fcfg'
else:
self._gramfile = gramfile
self._threads = {}
self._filtered_threads = {}
self._parser = parse.load_earley(self._gramfile)
if background is not None:
for e in background:
assert isinstance(e, Expression)
self._background = background
else:
self._background = []
def earley_parse(sentence="every cat leaves"):
from nltk.parse import load_earley
cp = load_earley(r"grammars/gluesemantics.fcfg")
tokens = sentence.split()
trees = cp.nbest_parse(tokens)
return trees
def __init__(self, gramfile=None):
"""
@parameter gramfile: name of file where grammar can be loaded
@type gramfile: C{str}
"""
if gramfile is None:
self._gramfile = 'grammars/sample_grammars/sem4.fcfg'
else:
self._gramfile = gramfile
self._parser = parse.load_earley(self._gramfile)
def parse_with_bindops(sentence, grammar=None, trace=0):
"""
Use a grammar with Binding Operators to parse a sentence.
"""
if not grammar:
grammar = 'grammars/book_grammars/storage.fcfg'
parser = load_earley(grammar,
trace=trace,
chart_class=InstantiateVarsChart)
# Parse the sentence.
tokens = sentence.split()
return parser.nbest_parse(tokens)
def main():
import sys
from optparse import OptionParser, OptionGroup
usage = """%%prog [options] [grammar_file]""" % globals()
opts = OptionParser(usage=usage)
opts.add_option("-c", "--components",
action="store_true", dest="show_components", default=0,
help="show hole semantics components")
opts.add_option("-r", "--raw",
action="store_true", dest="show_raw", default=0,
help="show the raw hole semantics expression")
opts.add_option("-d", "--drawtrees",
action="store_true", dest="draw_trees", default=0,
help="show formula trees in a GUI window")
opts.add_option("-v", "--verbose",
action="count", dest="verbosity", default=0,
help="show more information during parse")
(options, args) = opts.parse_args()
if len(args) > 0:
filename = args[0]
else:
filename = 'grammars/hole.fcfg'
print 'Reading grammar file', filename
#grammar = data.load(filename)
parser = load_earley(filename, trace=options.verbosity)
# Prompt the user for a sentence.
print 'Sentence: ',
line = sys.stdin.readline()[:-1]
# Parse the sentence.
tokens = line.split()
trees = parser.nbest_parse(tokens)
print 'Got %d different parses' % len(trees)
for tree in trees:
# Get the semantic feature from the top of the parse tree.
sem = tree[0].node['sem'].simplify()
# Skolemise away all quantifiers. All variables become unique.
sem = sem.skolemise()
# Reparse the semantic representation from its bracketed string format.
# I find this uniform structure easier to handle. It also makes the
# code mostly independent of the lambda calculus classes.
usr = bracket_parse(str(sem))
# Break the hole semantics representation down into its components
# i.e. holes, labels, formula fragments and constraints.
hole_sem = HoleSemantics(usr)
# Maybe print the raw semantic representation.
if options.show_raw:
print
print 'Raw expression'
print usr
# Maybe show the details of the semantic representation.
if options.show_components:
print
print 'Holes: ', hole_sem.holes
print 'Labels: ', hole_sem.labels
print 'Constraints: ', hole_sem.constraints
print 'Top hole: ', hole_sem.top_hole
print 'Top labels: ', hole_sem.top_most_labels
print 'Fragments:'
for (l,f) in hole_sem.fragments.items():
print '\t%s: %s' % (l, f)
# Find all the possible ways to plug the formulas together.
pluggings = hole_sem.pluggings()
# Build FOL formula trees using the pluggings.
trees = map(hole_sem.formula_tree, pluggings)
# Print out the formulas in a textual format.
n = 1
for tree in trees:
print
print '%d. %s' % (n, tree)
n += 1
# Maybe draw the formulas as trees.
if options.draw_trees:
draw_trees(*trees)
print
print 'Done.'
def earley_parse(sentence='every cat leaves'):
from nltk.parse import load_earley
cp = load_earley(r'grammars/gluesemantics.fcfg')
tokens = sentence.split()
trees = cp.nbest_parse(tokens)
return trees
