def testSection10(self):
lexicon = Lexicon.getDefaultLexicon() # default simplenlg lexicon
nlgFactory = NLGFactory( lexicon ) # factory based on lexicon
realiser = Realiser( lexicon )
subject1 = nlgFactory.createNounPhrase( "Mary" )
subject2 = nlgFactory.createNounPhrase( "your", "giraffe" )
# next line is not correct ~ should be nlgFactory.createCoordinatedPhrase ~ may be corrected in the API
subj = nlgFactory.createCoordinatedPhrase( subject1, subject2 )
verb = nlgFactory.createVerbPhrase( "chase" )
p = nlgFactory.createClause()
p.setSubject( subj )
p.setVerb( verb )
p.setObject( "the monkey" )
outputA = realiser.realiseSentence( p )
self.assertEqual( "Mary and your giraffe chase the monkey.", outputA )
object1 = nlgFactory.createNounPhrase( "the monkey" )
object2 = nlgFactory.createNounPhrase( "George" )
# next line is not correct ~ should be nlgFactory.createCoordinatedPhrase ~ may be corrected in the API
obj = nlgFactory.createCoordinatedPhrase( object1, object2 )
obj.addCoordinate( "Martha" )
p.setObject( obj )
outputB = realiser.realiseSentence( p )
self.assertEqual( "Mary and your giraffe chase the monkey, George and Martha.", outputB )
obj.setFeature( Feature.CONJUNCTION, "or" )
outputC = realiser.realiseSentence( p )
self.assertEqual( "Mary and your giraffe chase the monkey, George or Martha.", outputC )
def testSection11(self):
lexicon = Lexicon.getDefaultLexicon()
nlgFactory = NLGFactory( lexicon )
realiser = Realiser( lexicon )
pA = nlgFactory.createClause( "Mary", "chase", "the monkey" )
pA.addComplement( "in the park" )
outputA = realiser.realiseSentence( pA )
self.assertEqual( "Mary chases the monkey in the park.", outputA )
# alternative build paradigm
place = nlgFactory.createNounPhrase( "park" )
pB = nlgFactory.createClause( "Mary", "chase", "the monkey" )
# next line is depreciated ~ may be corrected in the API
place.setDeterminer( "the" )
pp = nlgFactory.createPrepositionPhrase()
pp.addComplement( place )
pp.setPreposition( "in" )
pB.addComplement( pp )
outputB = realiser.realiseSentence( pB )
self.assertEqual( "Mary chases the monkey in the park.", outputB )
place.addPreModifier( "leafy" )
outputC = realiser.realiseSentence( pB )
self.assertEqual( "Mary chases the monkey in the leafy park.", outputC )
class PremodifierTest(unittest.TestCase):
# @Before
def setUp(self):
self.lexicon = Lexicon.getDefaultLexicon()
self.phraseFactory = NLGFactory(self.lexicon)
self.realiser = Realiser(self.lexicon)
# Test change from "a" to "an" in the presence of a premodifier with a vowel
def testIndefiniteWithPremodifier(self):
s = self.phraseFactory.createClause("there", "be")
s.setFeature(Feature.TENSE, Tense.PRESENT)
np = self.phraseFactory.createNounPhrase("a", "stenosis")
s.setObject(np)
# check without modifiers -- article should be "a"
self.assertEqual("there is a stenosis",
self.realiser.realise(s).getRealisation())
# add a single modifier -- should turn article to "an"
np.addPreModifier(
self.phraseFactory.createAdjectivePhrase("eccentric"))
self.assertEqual("there is an eccentric stenosis",
self.realiser.realise(s).getRealisation())
# Test for comma separation between premodifers
def testMultipleAdjPremodifiers(self):
np = self.phraseFactory.createNounPhrase("a", "stenosis")
np.addPreModifier(
self.phraseFactory.createAdjectivePhrase("eccentric"))
np.addPreModifier(self.phraseFactory.createAdjectivePhrase("discrete"))
self.assertEqual("an eccentric, discrete stenosis",
self.realiser.realise(np).getRealisation())
# Test for comma separation between verb premodifiers
def testMultipleAdvPremodifiers(self):
adv1 = self.phraseFactory.createAdverbPhrase("slowly")
adv2 = self.phraseFactory.createAdverbPhrase("discretely")
# case 1: concatenated premods: should have comma
vp = self.phraseFactory.createVerbPhrase("run")
vp.addPreModifier(adv1)
vp.addPreModifier(adv2)
self.assertEqual("slowly, discretely runs",
self.realiser.realise(vp).getRealisation())
# case 2: coordinated premods: no comma
vp2 = self.phraseFactory.createVerbPhrase("eat")
vp2.addPreModifier(
self.phraseFactory.createCoordinatedPhrase(adv1, adv2))
self.assertEqual("slowly and discretely eats",
self.realiser.realise(vp2).getRealisation())
def testVariants(self):
lexicon = Lexicon.getDefaultLexicon()
nlgFactory = NLGFactory(lexicon)
realiser = Realiser(lexicon)
p = nlgFactory.createClause()
p.setSubject("my dog")
p.setVerb("is") # variant of be
p.setObject("George")
output = realiser.realiseSentence(p)
self.assertEqual("My dog is George.", output)
p = nlgFactory.createClause()
p.setSubject("my dog")
p.setVerb("chases") # variant of chase
p.setObject("George")
output = realiser.realiseSentence(p)
self.assertEqual("My dog chases George.", output)
p = nlgFactory.createClause()
p.setSubject(nlgFactory.createNounPhrase("the", "dogs")) # variant of "dog"
p.setVerb("is") # variant of be
p.setObject("happy") # variant of happy
output = realiser.realiseSentence(p)
self.assertEqual("The dog is happy.", output)
p = nlgFactory.createClause()
p.setSubject(nlgFactory.createNounPhrase("the", "children")) # variant of "child"
p.setVerb("is") # variant of be
p.setObject("happy") # variant of happy
output = realiser.realiseSentence(p)
self.assertEqual("The child is happy.", output)
# following functionality is enabled
p = nlgFactory.createClause()
p.setSubject(nlgFactory.createNounPhrase("the", "dogs")) # variant of "dog"
p.setVerb("is") # variant of be
p.setObject("happy") # variant of happy
output = realiser.realiseSentence(p)
self.assertEqual("The dog is happy.", output) #corrected automatically
def testSection8(self):
lexicon = Lexicon.getDefaultLexicon()
nlgFactory = NLGFactory( lexicon )
realiser = Realiser( lexicon )
subject = nlgFactory.createNounPhrase( "Mary" )
object = nlgFactory.createNounPhrase( "the monkey" )
verb = nlgFactory.createVerbPhrase( "chase" )
subject.addModifier( "fast" )
p = nlgFactory.createClause()
p.setSubject( subject )
p.setVerb( verb )
p.setObject( object )
outputA = realiser.realiseSentence( p )
self.assertEqual( "Fast Mary chases the monkey.", outputA )
verb.addModifier( "quickly" )
outputB = realiser.realiseSentence( p )
self.assertEqual( "Fast Mary quickly chases the monkey.", outputB )
class StandAloneExample(unittest.TestCase):
def setUp(self):
self.lexicon = XMLLexicon()
self.nlgFactory = NLGFactory(self.lexicon)
self.realiser = Realiser(self.lexicon)
def testSentenceCreation(self):
# create sentences
thePark = self.nlgFactory.createNounPhrase("the", "park")
bigp = self.nlgFactory.createAdjectivePhrase("big")
bigp.setFeature(Feature.IS_COMPARATIVE, True)
thePark.addModifier(bigp)
# above relies on default placement rules. You can force placement as a premodifier
# (before head) by using addPreModifier
toThePark = self.nlgFactory.createPrepositionPhrase("to")
toThePark.setObject(thePark)
# could also just say self.nlgFactory.createPrepositionPhrase("to", the Park)
johnGoToThePark = self.nlgFactory.createClause("John", "go", toThePark)
johnGoToThePark.setFeature(Feature.TENSE, Tense.PAST)
johnGoToThePark.setFeature(Feature.NEGATED, True)
# note that constituents (such as subject and object) are set with setXXX methods
# while features are set with setFeature
sentence = self.nlgFactory.createSentence(johnGoToThePark)
# below creates a sentence DocumentElement by concatenating strings
hePlayed = StringElement("he played")
there = StringElement("there")
football = WordElement("football")
sentence2 = self.nlgFactory.createSentence()
sentence2.addComponent(hePlayed)
sentence2.addComponent(football)
sentence2.addComponent(there)
# now create a paragraph which contains these sentences
paragraph = self.nlgFactory.createParagraph()
paragraph.addComponent(sentence)
paragraph.addComponent(sentence2)
realised = self.realiser.realise(paragraph).getRealisation()
# Test
self.assertEqual(
"John did not go to the bigger park. He played football there.\n\n",
realised)
def testMorphology(self):
# second example - using simplenlg just for morphology
word = self.nlgFactory.createWord("child", LexicalCategory.NOUN)
# create InflectedWordElement from word element
inflectedWord = InflectedWordElement(word)
# set the inflected word to plural
inflectedWord.setPlural(True)
# realise the inflected word
realised = self.realiser.realise(inflectedWord).getRealisation()
# Test
self.assertEqual('children', realised)
class RealiserTest(unittest.TestCase):
def setUp(self):
self.lexicon = Lexicon.getDefaultLexicon()
self.nlgFactory = NLGFactory(self.lexicon)
self.realiser = Realiser(self.lexicon)
#self.realiser.setDebugMode(True)
# Test the realization of List of NLGElements that is null
def testEmptyNLGElementRealiser(self):
elements = []
realisedElements = self.realiser.realise(elements)
# Expect emtpy listed returned:
self.assertIsNotNone(realisedElements)
self.assertEqual(0, len(realisedElements))
# Test the realization of List of NLGElements that is null
def testNullNLGElementRealiser(self):
elements = None
realisedElements = self.realiser.realise(elements)
# Expect emtpy listed returned:
self.assertIsNotNone(realisedElements)
self.assertEqual(0, len(realisedElements))
# Tests the realization of multiple NLGElements in a list.
def testMultipleNLGElementListRealiser(self):
# "The cat jumping on the counter."
sentence1 = self.nlgFactory.createSentence()
subject_1 = self.nlgFactory.createNounPhrase("the", "cat")
verb_1 = self.nlgFactory.createVerbPhrase("jump")
verb_1.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE)
prep_1 = self.nlgFactory.createPrepositionPhrase()
object_1 = self.nlgFactory.createNounPhrase()
object_1.setDeterminer("the")
object_1.setNoun("counter")
prep_1.addComplement(object_1)
prep_1.setPreposition("on")
clause_1 = self.nlgFactory.createClause()
clause_1.setSubject(subject_1)
clause_1.setVerbPhrase(verb_1)
clause_1.setObject(prep_1)
sentence1.addComponent(clause_1)
# "The dog running on the counter."
sentence2 = self.nlgFactory.createSentence()
subject_2 = self.nlgFactory.createNounPhrase("the", "dog")
verb_2 = self.nlgFactory.createVerbPhrase("run")
verb_2.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE)
prep_2 = self.nlgFactory.createPrepositionPhrase()
object_2 = self.nlgFactory.createNounPhrase()
object_2.setDeterminer("the")
object_2.setNoun("counter")
prep_2.addComplement(object_2)
prep_2.setPreposition("on")
clause_2 = self.nlgFactory.createClause()
clause_2.setSubject(subject_2)
clause_2.setVerbPhrase(verb_2)
clause_2.setObject(prep_2)
sentence2.addComponent(clause_2)
# Create test NLGElements to realize:
elements = [sentence1, sentence2]
realisedElements = self.realiser.realise(elements)
#
self.assertIsNotNone(realisedElements)
self.assertEqual(2, len(realisedElements))
self.assertEqual("The cat jumping on the counter.",
realisedElements[0].getRealisation())
self.assertEqual("The dog running on the counter.",
realisedElements[1].getRealisation())
# Tests the correct pluralization with possessives (GitHub issue #9)
def testCorrectPluralizationWithPossessives(self):
sisterNP = self.nlgFactory.createNounPhrase("sister")
word = self.nlgFactory.createInflectedWord("Albert Einstein",
LexicalCategory.NOUN)
word.setFeature(LexicalFeature.PROPER, True)
possNP = self.nlgFactory.createNounPhrase(word)
possNP.setFeature(Feature.POSSESSIVE, True)
sisterNP.setSpecifier(possNP)
self.assertEqual("Albert Einstein's sister",
self.realiser.realise(sisterNP).getRealisation())
sisterNP.setPlural(True)
self.assertEqual("Albert Einstein's sisters",
self.realiser.realise(sisterNP).getRealisation())
sisterNP.setPlural(False)
possNP.setFeature(LexicalFeature.GENDER, Gender.MASCULINE)
possNP.setFeature(Feature.PRONOMINAL, True)
self.assertEqual("his sister",
self.realiser.realise(sisterNP).getRealisation())
sisterNP.setPlural(True)
self.assertEqual("his sisters",
self.realiser.realise(sisterNP).getRealisation())
class Realizer(object):
def __init__(self):
verb2noun, noun2verb, verb2actor, actor2verb = utils.noun_verb(
prop.morph_verb)
self.verb2noun = verb2noun
self.verb2actor = verb2actor
sub2word = utils.subgraph_word(prop.verbalization)
self.sub2word = sub2word
lexicon = Lexicon.getDefaultLexicon()
self.nlgFactory = NLGFactory(lexicon)
self.realiser = Realiser(lexicon)
def create_clause(self, subject, vp, _object, frontmodifiers, complements):
phrase = self.nlgFactory.createClause()
phrase.setSubject(subject)
phrase.setVerbPhrase(vp)
if _object != None:
phrase.setObject(_object)
for frontmodifier in frontmodifiers:
phrase = self.add_frontmodifier(phrase, frontmodifier)
for complement in complements:
phrase = self.add_complement(phrase, complement)
return phrase
def create_np(self, determiner, head, number, premodifiers, postmodifiers):
np = self.nlgFactory.createNounPhrase()
np.setNoun(head)
if determiner != '':
np.setDeterminer(determiner)
if number == 'singular':
np.setFeature(Feature.NUMBER, NumberAgreement.SINGULAR)
elif number == 'plural':
np.setFeature(Feature.NUMBER, NumberAgreement.PLURAL)
for premodifier in premodifiers:
np = self.add_premodifier(np, premodifier)
for postmodifier in postmodifiers:
np = self.add_postmodifier(np, postmodifier)
return np
def create_vp(self, sentence):
verb = sentence['verb']
voice = sentence['voice']
tense = sentence['tense']
perfect = sentence['perfect']
form = sentence['form']
modal = sentence['modal']
vp = self.nlgFactory.createVerbPhrase()
vp.setVerb(verb)
if tense == "past":
vp.setFeature(Feature.TENSE, Tense.PAST)
elif tense == "present":
vp.setFeature(Feature.TENSE, Tense.PRESENT)
elif tense == "future":
vp.setFeature(Feature.TENSE, Tense.FUTURE)
if voice == "active":
vp.setFeature(Feature.PASSIVE, Boolean(False))
else:
vp.setFeature(Feature.PASSIVE, Boolean(True))
if perfect:
vp.setFeature(Feature.PERFECT, Boolean(True))
else:
vp.setFeature(Feature.PERFECT, Boolean(False))
if form == 'negative':
vp.setFeature(Feature.NEGATED, Boolean(True))
elif form == 'infinitive':
vp.setFeature(Feature.FORM, Form.INFINITIVE)
if modal == 'possible':
vp.setFeature(Feature.MODAL, "can")
elif modal == 'obligate':
vp.setFeature(Feature.MODAL, "must")
elif modal == 'permit':
vp.setFeature(Feature.MODAL, "may")
elif modal == 'recommend':
vp.setFeature(Feature.MODAL, "should")
return vp
def create_pp(self, preposition, np):
pp = self.nlgFactory.createPrepositionPhrase()
pp.addComplement(np)
pp.setPreposition(preposition)
return pp
def create_adjp(self, adjective):
adjp = self.nlgFactory.createAdjectivePhrase(adjective)
return adjp
def create_advp(self, adverb):
advp = self.nlgFactory.createAdverbPhrase(adverb)
return advp
def create_possessive(self):
np = self.nlgFactory.createNounPhrase()
np.setFeature(Feature.PRONOMINAL, Boolean(True))
np.setFeature(Feature.POSSESSIVE, Boolean(True))
return np
def add_complement(self, phrase, complement):
phrase.addComplement(complement)
return phrase
def add_premodifier(self, phrase, premodifier):
phrase.addPreModifier(premodifier)
return phrase
def add_postmodifier(self, phrase, postmodifier):
phrase.addPostModifier(postmodifier)
return phrase
def add_frontmodifier(self, phrase, frontmodifier):
phrase.addFrontModifier(frontmodifier)
return phrase
def add_complementiser(self, phrase, complement):
phrase.setFeature(Feature.COMPLEMENTISER, complement)
return phrase
def process_np(self, root):
determiner, premodifiers, head, postmodifiers = '', [], '', []
for node in self.tree.edges[root]:
if self.tree.nodes[node].type == 'terminal':
if self.tree.nodes[node].name == 'DT':
determiner = self.tree.nodes[node].lexicon
elif self.tree.nodes[node].label > -1 and self.tree.nodes[
node].rule_id == self.tree.nodes[root].rule_id:
head = self.tree.nodes[node].lexicon
elif self.tree.nodes[node].name == 'PRP$':
mod = self.create_possessive()
premodifiers.append(mod)
else:
mod = self.tree.nodes[node].lexicon
if head == '':
premodifiers.append(mod)
else:
postmodifiers.append(mod)
else:
mod = self.process(node)
if mod != None:
if head == '':
premodifiers.append(mod)
else:
postmodifiers.append(mod)
if head == '':
head = copy.copy(determiner)
determiner = ''
p = self.create_np(determiner=determiner,
head=head,
number='singular',
premodifiers=premodifiers,
postmodifiers=postmodifiers)
return p
def process_vp(self, root, sentence):
for node in self.tree.edges[root]:
if self.tree.nodes[node].type == 'terminal':
# treat modals
if self.tree.nodes[node].name == 'MD':
sentence['modal'] = self.tree.nodes[node].lexicon
# treat infinitive
elif self.tree.nodes[node].name == 'TO':
sentence['form'] = 'infinitive'
# treat negative
elif self.tree.nodes[node].lexicon == 'not':
sentence['form'] = 'negative'
elif self.tree.nodes[node].name == 'VB':
sentence['verb'] = self.tree.nodes[node].lexicon
# if self.tree.nodes[node].label > -1 and self.tree.nodes[node].rule_id == self.tree.nodes[root].rule_id:
# sentence['verb'] = self.tree.nodes[node].lexicon
else:
if self.tree.nodes[node].name == 'VP':
sentence = self.process_vp(node, sentence)
else:
p = self.process(node)
if p != None:
rule_id = self.tree.nodes[node].rule_id
rule = self.synchg.rules[rule_id]
edge = rule.name.split('/')[0]
pos = self.tree.nodes[node].name
if 'NP' in pos:
if edge == ':ARG1' and sentence[
'voice'] == 'active':
sentence['object'] = p
else:
sentence['complements'].append(p)
elif pos == 'PP':
if edge == ':ARG0' and sentence[
'voice'] == 'passive':
p = p.getChildren()[1]
sentence['subject'] = p
else:
sentence['complements'].append(p)
else:
sentence['complements'].append(p)
return sentence
def process_pp(self, root):
preposition, np = '', None
for node in self.tree.edges[root]:
if self.tree.nodes[node].type == 'terminal':
preposition = self.tree.nodes[node].lexicon
else:
np = self.process(node)
p = self.create_pp(preposition, np)
return p
def process_adjvp(self, root):
premodifiers, head, postmodifiers = [], '', []
for node in self.tree.edges[root]:
if self.tree.nodes[node].type == 'terminal':
if self.tree.nodes[node].label > -1 and self.tree.nodes[
node].rule_id == self.tree.nodes[root].rule_id:
head = self.tree.nodes[node].lexicon
else:
mod = self.tree.nodes[node].lexicon
if head == '':
premodifiers.append(mod)
else:
postmodifiers.append(mod)
else:
mod = self.process(node)
if head == '':
premodifiers.append(mod)
else:
postmodifiers.append(mod)
if self.tree.nodes[root].name == 'ADJP':
p = self.create_adjp(head)
else:
p = self.create_advp(head)
for premodifier in premodifiers:
self.add_premodifier(p, premodifier)
for postmodifier in postmodifiers:
self.add_postmodifier(p, postmodifier)
return p
def process_s(self, root):
# get voice
rule_id = self.tree.nodes[root].rule_id
rule = self.synchg.rules[rule_id]
voice = rule.features.voice
sentence = {
'subject': None,
'object': None,
'verb': '',
'tense': 'present',
'modal': '',
'voice': voice,
'perfect': False,
'form': 'affirmative',
'frontmodifiers': [],
'complements': []
}
for node in self.tree.edges[root]:
if self.tree.nodes[node].name not in ['.', ':']:
rule_id = self.tree.nodes[node].rule_id
rule = self.synchg.rules[rule_id]
edge = rule.name.split('/')[0]
pos = self.tree.nodes[node].name
if pos == 'VP':
sentence = self.process_vp(node, sentence)
else:
p = self.process(node)
if 'NP' in pos:
if edge == ':ARG0':
sentence['subject'] = p
elif edge == ':ARG1':
if voice == 'active':
sentence['subject'] = p
else:
sentence['object'] = p
else:
if sentence['verb'] == '':
sentence['frontmodifiers'].append(p)
else:
sentence['complements'].append(p)
elif pos == 'PP':
if edge == ':ARG0' and self.voice == 'passive':
p = p.getChildren()[1]
sentence['subject'] = p
else:
if sentence['verb'] == '':
sentence['frontmodifiers'].append(p)
else:
sentence['complements'].append(p)
vp = self.create_vp(sentence)
subject = sentence['subject']
object = sentence['object']
frontmodifiers = sentence['frontmodifiers']
complements = sentence['complements']
p = self.create_clause(subject=subject,
vp=vp,
_object=object,
frontmodifiers=frontmodifiers,
complements=complements)
return p
def process_sbar(self, root):
p, complement = None, 'that'
for node in self.tree.edges[root]:
if self.tree.nodes[node].name == 'S':
p = self.process_s(node)
elif self.tree.nodes[node].name[0] == 'W':
child = self.tree.edges[node][0]
complement = self.tree.nodes[child].lexicon
if p != None:
p = self.add_complementiser(p, complement)
return p
def check_coordination(self, root):
pass
def process(self, root):
if self.tree.nodes[root].name == 'S':
p = self.process_s(root)
# SUBORDINATE CLAUSE
elif self.tree.nodes[root].name == 'SBAR':
p = self.process_sbar(root)
# NOUN PHRASE
elif 'NP' in self.tree.nodes[root].name:
p = self.process_np(root)
# PREPOSITIONAL PHRASES
elif self.tree.nodes[root].name == 'PP':
p = self.process_pp(root)
# ADJECTIVE AND ADVERBIAL PHRASES
elif self.tree.nodes[root].name in ['ADJP', 'ADVP']:
p = self.process_adjvp(root)
elif self.tree.nodes[root].name == 'FRAG':
p = self.process(self.tree.edges[root][0])
else:
p = None
return p
def run(self, tree, synchg):
self.tree = tree
self.synchg = synchg
root = tree.root
# TO DO: treat multi sentences
if self.tree.nodes[root].name == 'MULTI-SENTENCE':
p = None
else:
root = self.tree.edges[self.tree.root][0]
self.subject, self.vp, self.object = None, None, None
self.complements, self.frontmodifiers = [], []
p = self.process(root)
if p != None:
return self.realiser.realise(p)
else:
return '-'
# from simplenlg.phrasespec.VPPhraseSpec import *
from simplenlg.realiser.english.Realiser import *
from simplenlg.phrasespec import *
# The hot resources :
# https://pypi.org/project/simplenlg/
# https://github.com/bjascob/pySimpleNLG
# https://github.com/simplenlg/simplenlg/wiki
lexicon = Lexicon.getDefaultLexicon()
factory = NLGFactory(lexicon)
realiser = Realiser(lexicon)
sentence1 = factory.createSentence()
subject1 = factory.createNounPhrase('the', 'cat')
sentence1.addComponent(subject1) # use addComponent not setSubject
verb1 = factory.createVerbPhrase('jump')
sentence1.addComponent(verb1)
print(realiser.realise(sentence1))
# sentence1.setFeature(Feature.TENSE, Tense.PAST)
# print(realiser.realise(sentence1)) -- don't work :(
# Look - using a clause instead of a sentence made tense switching work :
# the reason is because you can use setSubject on clauses, not sentences
clause2 = factory.createClause()
subject1 = factory.createNounPhrase('the', 'cat')
clause2.setSubject(subject1)
verb1 = factory.createVerbPhrase('jump')
clause2.setVerb(verb1)
print(realiser.realise(clause2))
class StringElementTest(unittest.TestCase):
def setUp(self):
self.lexicon = Lexicon.getDefaultLexicon()
self.phraseFactory = NLGFactory(self.lexicon)
self.realiser = Realiser(self.lexicon)
# Test that string elements can be used as heads of NP
def testStringElementAsHead(self):
np = self.phraseFactory.createNounPhrase()
np.setHead(self.phraseFactory.createStringElement("dogs and cats"))
np.setSpecifier(
self.phraseFactory.createWord("the", LexicalCategory.DETERMINER))
self.assertEqual("the dogs and cats",
self.realiser.realise(np).getRealisation())
# Sentences whose VP is a canned string
def testStringElementAsVP(self):
s = self.phraseFactory.createClause()
s.setVerbPhrase(
self.phraseFactory.createStringElement("eats and drinks"))
s.setSubject(self.phraseFactory.createStringElement("the big fat man"))
self.assertEqual("the big fat man eats and drinks",
self.realiser.realise(s).getRealisation())
# Test for when the SPhraseSpec has a NPSpec added directly after it:
# "Mary loves NP[the cow]."
def testTailNPStringElement(self):
senSpec = self.phraseFactory.createClause()
senSpec.addComplement(
(self.phraseFactory.createStringElement("mary loves")))
np = self.phraseFactory.createNounPhrase()
np.setHead("cow")
np.setDeterminer("the")
senSpec.addComplement(np)
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("Mary loves the cow.",
self.realiser.realise(completeSen).getRealisation())
# Test for a NP followed by a canned text: "NP[A cat] loves a dog".
def testFrontNPStringElement(self):
senSpec = self.phraseFactory.createClause()
np = self.phraseFactory.createNounPhrase()
np.setHead("cat")
np.setDeterminer("the")
senSpec.addComplement(np)
senSpec.addComplement(
self.phraseFactory.createStringElement("loves a dog"))
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("The cat loves a dog.", \
self.realiser.realise(completeSen).getRealisation())
# Test for a StringElement followed by a NP followed by a StringElement
# "The world loves NP[ABBA] but not a sore loser."
def testMulitpleStringElements(self):
senSpec = self.phraseFactory.createClause()
senSpec.addComplement(
self.phraseFactory.createStringElement("the world loves"))
np = self.phraseFactory.createNounPhrase()
np.setHead("ABBA")
senSpec.addComplement(np)
senSpec.addComplement(
self.phraseFactory.createStringElement("but not a sore loser"))
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("The world loves ABBA but not a sore loser.", \
self.realiser.realise(completeSen).getRealisation())
# Test for multiple NP phrases with a single StringElement phrase:
# "NP[John is] a trier NP[for cheese]."
def testMulitpleNPElements(self):
senSpec = self.phraseFactory.createClause()
frontNoun = self.phraseFactory.createNounPhrase()
frontNoun.setHead("john")
senSpec.addComplement(frontNoun)
senSpec.addComplement(
self.phraseFactory.createStringElement("is a trier"))
backNoun = self.phraseFactory.createNounPhrase()
backNoun.setDeterminer("for")
backNoun.setNoun("cheese")
senSpec.addComplement(backNoun)
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("John is a trier for cheese.", \
self.realiser.realise(completeSen).getRealisation())
# White space check: Test to see how SNLG deals with additional whitespaces:
# NP[The Nasdaq] rose steadily during NP[early trading], however it plummeted due to NP[a shock] after NP[IBM] announced poor
# NP[first quarter results].
def testWhiteSpaceNP(self):
senSpec = self.phraseFactory.createClause()
firstNoun = self.phraseFactory.createNounPhrase()
firstNoun.setDeterminer("the")
firstNoun.setNoun("Nasdaq")
senSpec.addComplement(firstNoun)
senSpec.addComplement(
self.phraseFactory.createStringElement(" rose steadily during "))
secondNoun = self.phraseFactory.createNounPhrase()
secondNoun.setSpecifier("early")
secondNoun.setNoun("trading")
senSpec.addComplement(secondNoun)
senSpec.addComplement(
self.phraseFactory.createStringElement(
" , however it plummeted due to"))
thirdNoun = self.phraseFactory.createNounPhrase()
thirdNoun.setSpecifier("a")
thirdNoun.setNoun("shock")
senSpec.addComplement(thirdNoun)
senSpec.addComplement(
self.phraseFactory.createStringElement(" after "))
fourthNoun = self.phraseFactory.createNounPhrase()
fourthNoun.setNoun("IBM")
senSpec.addComplement(fourthNoun)
senSpec.addComplement(
self.phraseFactory.createStringElement("announced poor "))
fifthNoun = self.phraseFactory.createNounPhrase()
fifthNoun.setSpecifier("first quarter")
fifthNoun.setNoun("results")
fifthNoun.setPlural(True)
senSpec.addComplement(fifthNoun)
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
correct = "The Nasdaq rose steadily during early trading, however it plummeted " \
+ "due to a shock after IBM announced poor first quarter results."
self.assertEqual(correct,
self.realiser.realise(completeSen).getRealisation())
# Point absorption test: Check to see if SNLG respects abbreviations at the end of a sentence.
# "NP[Yahya] was sleeping his own and dreaming etc."
def testPointAbsorption(self):
senSpec = self.phraseFactory.createClause()
firstNoun = self.phraseFactory.createNounPhrase()
firstNoun.setNoun("yaha")
senSpec.addComplement(firstNoun)
senSpec.addComplement("was sleeping on his own and dreaming etc.")
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("Yaha was sleeping on his own and dreaming etc.", \
self.realiser.realise(completeSen).getRealisation())
# Point absorption test: As above, but with trailing white space.
# "NP[Yaha] was sleeping his own and dreaming etc. "
def testPointAbsorptionTrailingWhiteSpace(self):
senSpec = self.phraseFactory.createClause()
firstNoun = self.phraseFactory.createNounPhrase()
firstNoun.setNoun("yaha")
senSpec.addComplement(firstNoun)
senSpec.addComplement(
"was sleeping on his own and dreaming etc. ")
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("Yaha was sleeping on his own and dreaming etc.", \
self.realiser.realise(completeSen).getRealisation())
# Abbreviation test: Check to see how SNLG deals with abbreviations in the middle of a sentence.
# "NP[Yahya] and friends etc. went to NP[the park] to play."
def testMiddleAbbreviation(self):
senSpec = self.phraseFactory.createClause()
firstNoun = self.phraseFactory.createNounPhrase()
firstNoun.setNoun("yahya")
senSpec.addComplement(firstNoun)
senSpec.addComplement(
self.phraseFactory.createStringElement("and friends etc. went to"))
secondNoun = self.phraseFactory.createNounPhrase()
secondNoun.setDeterminer("the")
secondNoun.setNoun("park")
senSpec.addComplement(secondNoun)
senSpec.addComplement("to play")
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("Yahya and friends etc. went to the park to play.", \
self.realiser.realise(completeSen).getRealisation())
# Indefinite Article Inflection: StringElement to test how SNLG handles a/an situations.
# "I see an NP[elephant]"
def testStringIndefiniteArticleInflectionVowel(self):
senSpec = self.phraseFactory.createClause()
senSpec.addComplement(
self.phraseFactory.createStringElement("I see a"))
firstNoun = self.phraseFactory.createNounPhrase("elephant")
senSpec.addComplement(firstNoun)
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("I see an elephant.",
self.realiser.realise(completeSen).getRealisation())
# Indefinite Article Inflection: StringElement to test how SNLG handles a/an situations.
# "I see NP[a elephant]" -->
def testNPIndefiniteArticleInflectionVowel(self):
senSpec = self.phraseFactory.createClause()
senSpec.addComplement(self.phraseFactory.createStringElement("I see"))
firstNoun = self.phraseFactory.createNounPhrase("elephant")
firstNoun.setDeterminer("a")
senSpec.addComplement(firstNoun)
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
self.assertEqual("I see an elephant.",
self.realiser.realise(completeSen).getRealisation())
'''
# Not useful in python. Java code returns "I see an cow." (ie.. it doesn't change the article)
# assertNotSame simply verifies that two objects do not refer to the same object.
# Indefinite Article Inflection: StringElement to test how SNLG handles a/an situations.
# "I see an NP[cow]"
def testStringIndefiniteArticleInflectionConsonant(self):
senSpec = self.phraseFactory.createClause()
senSpec.addComplement(self.phraseFactory.createStringElement("I see an"))
firstNoun = self.phraseFactory.createNounPhrase("cow")
senSpec.addComplement(firstNoun)
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
# Do not attempt "an" -> "a"
self.assertNotSame("I see an cow.", self.realiser.realise(completeSen).getRealisation())
'''
# Indefinite Article Inflection: StringElement to test how SNLG handles a/an situations.
# "I see NP[an cow]" -->
def testNPIndefiniteArticleInflectionConsonant(self):
senSpec = self.phraseFactory.createClause()
senSpec.addComplement(self.phraseFactory.createStringElement("I see"))
firstNoun = self.phraseFactory.createNounPhrase("cow")
firstNoun.setDeterminer("an")
senSpec.addComplement(firstNoun)
completeSen = self.phraseFactory.createSentence()
completeSen.addComponent(senSpec)
# Do not attempt "an" -> "a"
self.assertEqual("I see an cow.",
self.realiser.realise(completeSen).getRealisation())
# aggregationStringElementTest: Test to see if we can aggregate two StringElements
# in a CoordinatedPhraseElement.
def testAggregationStringElement(self):
coordinate = self.phraseFactory.createCoordinatedPhrase( \
StringElement("John is going to Tesco"), StringElement("Mary is going to Sainsburys"))
sentence = self.phraseFactory.createClause()
sentence.addComplement(coordinate)
self.assertEqual("John is going to Tesco and Mary is going to Sainsburys.", \
self.realiser.realiseSentence(sentence))
# Tests that no empty space is added when a StringElement is instantiated with an empty string
# or None object.
def testNullAndEmptyStringElement(self):
NoneStringElement = self.phraseFactory.createStringElement(None)
emptyStringElement = self.phraseFactory.createStringElement("")
beautiful = self.phraseFactory.createStringElement("beautiful")
horseLike = self.phraseFactory.createStringElement("horse-like")
creature = self.phraseFactory.createStringElement("creature")
# Test1: None or empty at beginning
test1 = self.phraseFactory.createClause("a unicorn", "be",
"regarded as a")
test1.addPostModifier(emptyStringElement)
test1.addPostModifier(beautiful)
test1.addPostModifier(horseLike)
test1.addPostModifier(creature)
self.assertEqual("A unicorn is regarded as a beautiful horse-like creature.", \
self.realiser.realiseSentence(test1))
# Test2: empty or None at end
test2 = self.phraseFactory.createClause("a unicorn", "be",
"regarded as a")
test2.addPostModifier(beautiful)
test2.addPostModifier(horseLike)
test2.addPostModifier(creature)
test2.addPostModifier(NoneStringElement)
self.assertEqual("A unicorn is regarded as a beautiful horse-like creature.", \
self.realiser.realiseSentence(test2))
# Test3: empty or None in the middle
test3 = self.phraseFactory.createClause("a unicorn", "be",
"regarded as a")
test3.addPostModifier("beautiful")
test3.addPostModifier("horse-like")
test3.addPostModifier("")
test3.addPostModifier("creature")
self.assertEqual("A unicorn is regarded as a beautiful horse-like creature.", \
self.realiser.realiseSentence(test3))
# Test4: empty or None in the middle with empty or None at beginning
test4 = self.phraseFactory.createClause("a unicorn", "be",
"regarded as a")
test4.addPostModifier("")
test4.addPostModifier("beautiful")
test4.addPostModifier("horse-like")
test4.addPostModifier(NoneStringElement)
test4.addPostModifier("creature")
self.assertEqual("A unicorn is regarded as a beautiful horse-like creature.", \
self.realiser.realiseSentence(test4))
class SimpleNLG4Test(unittest.TestCase):
# Instantiates a new simplenlg test.
def SimpleNLG4Test(self, name):
super().__init__(name)
# Set up the variables we'll need for this simplenlg.test to run
# @Override @Before
def setUp(self):
self.lexicon = XMLLexicon()
self.phraseFactory = NLGFactory(self.lexicon)
self.realiser = Realiser(self.lexicon)
self.man = self.phraseFactory.createNounPhrase("the", "man")
self.woman = self.phraseFactory.createNounPhrase("the", "woman")
self.dog = self.phraseFactory.createNounPhrase("the", "dog")
self.boy = self.phraseFactory.createNounPhrase("the", "boy")
self.beautiful = self.phraseFactory.createAdjectivePhrase("beautiful")
self.stunning = self.phraseFactory.createAdjectivePhrase("stunning")
self.salacious = self.phraseFactory.createAdjectivePhrase("salacious")
self.onTheRock = self.phraseFactory.createPrepositionPhrase("on")
self.np4 = self.phraseFactory.createNounPhrase("the", "rock")
self.onTheRock.addComplement(self.np4)
self.behindTheCurtain = self.phraseFactory.createPrepositionPhrase("behind")
self.np5 = self.phraseFactory.createNounPhrase("the", "curtain")
self.behindTheCurtain.addComplement(self.np5)
self.inTheRoom = self.phraseFactory.createPrepositionPhrase("in")
self.np6 = self.phraseFactory.createNounPhrase("the", "room")
self.inTheRoom.addComplement(self.np6)
self.underTheTable = self.phraseFactory.createPrepositionPhrase("under")
self.underTheTable.addComplement(self.phraseFactory.createNounPhrase("the", "table"))
self.proTest1 = self.phraseFactory.createNounPhrase("the", "singer")
self.proTest2 = self.phraseFactory.createNounPhrase("some", "person")
self.kick = self.phraseFactory.createVerbPhrase("kick")
self.kiss = self.phraseFactory.createVerbPhrase("kiss")
self.walk = self.phraseFactory.createVerbPhrase("walk")
self.talk = self.phraseFactory.createVerbPhrase("talk")
self.getUp = self.phraseFactory.createVerbPhrase("get up")
self.fallDown = self.phraseFactory.createVerbPhrase("fall down")
self.give = self.phraseFactory.createVerbPhrase("give")
self.say = self.phraseFactory.createVerbPhrase("say")
# @Override @After
def tearDown(self):
self.lexicon = None
self.realiser = None
self.phraseFactory = None
self.man = None
self.woman = None
self.dog = None
self.boy = None
self.np4 = None
self.np5 = None
self.np6 = None
self.proTest1 = None
self.proTest2 = None
self.beautiful = None
self.stunning = None
self.salacious = None
self.onTheRock = None
self.behindTheCurtain= None
self.inTheRoom = None
self.underTheTable = None
self.kick = None
self.kiss = None
self.walk = None
self.talk = None
self.getUp = None
self.fallDown = None
self.give = None
self.say = None
class ExternalTest(unittest.TestCase):
# called before each test
def setUp(self):
self.lexicon = Lexicon.getDefaultLexicon()
self.phraseFactory = NLGFactory(self.lexicon)
self.realiser = Realiser(self.lexicon)
# Basic tests
def testForcher(self):
# Bjorn Forcher's tests
self.phraseFactory.setLexicon(self.lexicon)
s1 = self.phraseFactory.createClause(None, "associate", "Marie")
s1.setFeature(Feature.PASSIVE, True)
pp1 = self.phraseFactory.createPrepositionPhrase("with")
pp1.addComplement("Peter")
pp1.addComplement("Paul")
s1.addPostModifier(pp1)
self.assertEqual("Marie is associated with Peter and Paul",
self.realiser.realise(s1).getRealisation())
s2 = self.phraseFactory.createClause()
s2.setSubject(self.phraseFactory.createNounPhrase("Peter"))
s2.setVerb("have")
s2.setObject("something to do")
s2.addPostModifier(
self.phraseFactory.createPrepositionPhrase("with", "Paul"))
self.assertEqual("Peter has something to do with Paul",
self.realiser.realise(s2).getRealisation())
def testLu(self):
# Xin Lu's test
self.phraseFactory.setLexicon(self.lexicon)
s1 = self.phraseFactory.createClause("we", "consider", "John")
s1.addPostModifier("a friend")
self.assertEqual("we consider John a friend",
self.realiser.realise(s1).getRealisation())
def testDwight(self):
# Rachel Dwight's test
self.phraseFactory.setLexicon(self.lexicon)
noun4 = self.phraseFactory.createNounPhrase("FGFR3 gene in every cell")
noun4.setSpecifier("the")
prep1 = self.phraseFactory.createPrepositionPhrase("of", noun4)
noun1 = self.phraseFactory.createNounPhrase("the", "patient's mother")
noun2 = self.phraseFactory.createNounPhrase("the", "patient's father")
noun3 = self.phraseFactory.createNounPhrase("changed copy")
noun3.addPreModifier("one")
noun3.addComplement(prep1)
coordNoun1 = CoordinatedPhraseElement(noun1, noun2)
coordNoun1.setConjunction("or")
verbPhrase1 = self.phraseFactory.createVerbPhrase("have")
verbPhrase1.setFeature(Feature.TENSE, Tense.PRESENT)
sentence1 = self.phraseFactory.createClause(coordNoun1, verbPhrase1,
noun3)
#realiser.setDebugMode(True)
string = "the patient's mother or the patient's father has one changed copy of the FGFR3 gene in every cell"
self.assertEqual(string,
self.realiser.realise(sentence1).getRealisation())
# Rachel's second test
noun3 = self.phraseFactory.createNounPhrase("a", "gene test")
noun2 = self.phraseFactory.createNounPhrase("an", "LDL test")
noun1 = self.phraseFactory.createNounPhrase("the", "clinic")
verbPhrase1 = self.phraseFactory.createVerbPhrase("perform")
coord1 = CoordinatedPhraseElement(noun2, noun3)
sentence1 = self.phraseFactory.createClause(noun1, verbPhrase1, coord1)
sentence1.setFeature(Feature.TENSE, Tense.PAST)
self.assertEqual("the clinic performed an LDL test and a gene test", \
self.realiser.realise(sentence1).getRealisation())
def testNovelli(self):
# Nicole Novelli's test
p = self.phraseFactory.createClause("Mary", "chase", "George")
pp = self.phraseFactory.createPrepositionPhrase("in", "the park")
p.addPostModifier(pp)
self.assertEqual("Mary chases George in the park",
self.realiser.realise(p).getRealisation())
# another question from Nicole
run = self.phraseFactory.createClause("you", "go", "running")
run.setFeature(Feature.MODAL, "should")
run.addPreModifier("really")
think = self.phraseFactory.createClause("I", "think")
think.setObject(run)
run.setFeature(Feature.SUPRESSED_COMPLEMENTISER, True)
text = self.realiser.realise(think).getRealisation()
self.assertEqual("I think you should really go running", text)
def testPiotrek(self):
# Piotrek Smulikowski's test
self.phraseFactory.setLexicon(self.lexicon)
sent = self.phraseFactory.createClause("I", "shoot", "the duck")
sent.setFeature(Feature.TENSE, Tense.PAST)
loc = self.phraseFactory.createPrepositionPhrase(
"at", "the Shooting Range")
sent.addPostModifier(loc)
sent.setFeature(Feature.CUE_PHRASE, "then")
self.assertEqual("then I shot the duck at the Shooting Range", \
self.realiser.realise(sent).getRealisation())
def testPrescott(self):
# Michael Prescott's test
self.phraseFactory.setLexicon(self.lexicon)
embedded = self.phraseFactory.createClause("Jill", "prod", "Spot")
sent = self.phraseFactory.createClause("Jack", "see", embedded)
embedded.setFeature(Feature.SUPRESSED_COMPLEMENTISER, True)
embedded.setFeature(Feature.FORM, Form.BARE_INFINITIVE)
self.assertEqual("Jack sees Jill prod Spot",
self.realiser.realise(sent).getRealisation())
def testWissner(self):
# Michael Wissner's text
p = self.phraseFactory.createClause("a wolf", "eat")
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_OBJECT)
self.assertEqual("what does a wolf eat",
self.realiser.realise(p).getRealisation())
def testPhan(self):
# Thomas Phan's text
subjectElement = self.phraseFactory.createNounPhrase("I")
verbElement = self.phraseFactory.createVerbPhrase("run")
prepPhrase = self.phraseFactory.createPrepositionPhrase("from")
prepPhrase.addComplement("home")
verbElement.addComplement(prepPhrase)
newSentence = self.phraseFactory.createClause()
newSentence.setSubject(subjectElement)
newSentence.setVerbPhrase(verbElement)
self.assertEqual("I run from home",
self.realiser.realise(newSentence).getRealisation())
def testKerber(self):
# Frederic Kerber's tests
sp = self.phraseFactory.createClause("he", "need")
secondSp = self.phraseFactory.createClause()
secondSp.setVerb("build")
secondSp.setObject("a house")
secondSp.setFeature(Feature.FORM, Form.INFINITIVE)
sp.setObject("stone")
sp.addComplement(secondSp)
self.assertEqual("he needs stone to build a house",
self.realiser.realise(sp).getRealisation())
sp2 = self.phraseFactory.createClause("he", "give")
sp2.setIndirectObject("I")
sp2.setObject("the book")
self.assertEqual("he gives me the book",
self.realiser.realise(sp2).getRealisation())
def testStephenson(self):
# Bruce Stephenson's test
qs2 = self.phraseFactory.createClause()
qs2.setSubject("moles of Gold")
qs2.setVerb("are")
qs2.setFeature(Feature.NUMBER, NumberAgreement.PLURAL)
qs2.setFeature(Feature.PASSIVE, False)
qs2.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.HOW_MANY)
qs2.setObject("in a 2.50 g sample of pure Gold")
sentence = self.phraseFactory.createSentence(qs2)
self.assertEqual("How many moles of Gold are in a 2.50 g sample of pure Gold?", \
self.realiser.realise(sentence).getRealisation())
def testPierre(self):
# John Pierre's test
p = self.phraseFactory.createClause("Mary", "chase", "George")
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHAT_OBJECT)
self.assertEqual("What does Mary chase?",
self.realiser.realiseSentence(p))
p = self.phraseFactory.createClause("Mary", "chase", "George")
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.YES_NO)
self.assertEqual("Does Mary chase George?",
self.realiser.realiseSentence(p))
p = self.phraseFactory.createClause("Mary", "chase", "George")
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHERE)
self.assertEqual("Where does Mary chase George?",
self.realiser.realiseSentence(p))
p = self.phraseFactory.createClause("Mary", "chase", "George")
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHY)
self.assertEqual("Why does Mary chase George?",
self.realiser.realiseSentence(p))
p = self.phraseFactory.createClause("Mary", "chase", "George")
p.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.HOW)
self.assertEqual("How does Mary chase George?",
self.realiser.realiseSentence(p))
def testData2TextTest(self):
# Data2Text tests
# test OK to have number at end of sentence
p = self.phraseFactory.createClause("the dog", "weigh", "12")
self.assertEqual("The dog weighes 12.",
self.realiser.realiseSentence(p))
# test OK to have "there be" sentence with "there" as a StringElement
dataDropout2 = self.phraseFactory.createNLGElement("data dropouts")
dataDropout2.setPlural(True)
sentence2 = self.phraseFactory.createClause()
sentence2.setSubject(self.phraseFactory.createStringElement("there"))
sentence2.setVerb("be")
sentence2.setObject(dataDropout2)
self.assertEqual("There are data dropouts.",
self.realiser.realiseSentence(sentence2))
# test OK to have gerund form verb
weather1 = self.phraseFactory.createClause("SE 10-15", "veer",
"S 15-20")
weather1.setFeature(Feature.FORM, Form.GERUND)
self.assertEqual("SE 10-15 veering S 15-20.",
self.realiser.realiseSentence(weather1))
# test OK to have subject only
weather2 = self.phraseFactory.createClause("cloudy and misty", "be",
"XXX")
weather2.getVerbPhrase().setFeature(Feature.ELIDED, True)
self.assertEqual("Cloudy and misty.",
self.realiser.realiseSentence(weather2))
# test OK to have VP only
weather3 = self.phraseFactory.createClause("S 15-20", "increase",
"20-25")
weather3.setFeature(Feature.FORM, Form.GERUND)
weather3.getSubject().setFeature(Feature.ELIDED, True)
self.assertEqual("Increasing 20-25.",
self.realiser.realiseSentence(weather3))
# conjoined test
weather4 = self.phraseFactory.createClause("S 20-25", "back", "SSE")
weather4.setFeature(Feature.FORM, Form.GERUND)
weather4.getSubject().setFeature(Feature.ELIDED, True)
coord = CoordinatedPhraseElement()
coord.addCoordinate(weather1)
coord.addCoordinate(weather3)
coord.addCoordinate(weather4)
coord.setConjunction("then")
self.assertEqual(
"SE 10-15 veering S 15-20, increasing 20-25 then backing SSE.",
self.realiser.realiseSentence(coord))
# no verb
weather5 = self.phraseFactory.createClause("rain", None, "likely")
self.assertEqual("Rain likely.",
self.realiser.realiseSentence(weather5))
@unittest.skip('aggregation not implemented')
def testRafael(self):
# Rafael Valle's tests
ss = []
coord = ClauseCoordinationRule()
coord.setFactory(self.phraseFactory)
ss.add(self.agreePhrase("John Lennon")) # john lennon agreed with it
ss.add(self.disagreePhrase(
"Geri Halliwell")) # Geri Halliwell disagreed with it
ss.add(self.commentPhrase("Melanie B")) # Mealnie B commented on it
ss.add(self.agreePhrase("you")) # you agreed with it
ss.add(self.commentPhrase("Emma Bunton")) #Emma Bunton commented on it
results = coord.apply(ss)
ret = [self.realiser.realise(e).getRealisation() for e in results]
string = "[John Lennon and you agreed with it, Geri Halliwell disagreed with it, Melanie B and Emma Bunton commented on it]"
self.assertEqual(string, ret.toString())
def commentPhrase(self, name): # used by testRafael
s = self.phraseFactory.createClause()
s.setSubject(self.phraseFactory.createNounPhrase(name))
s.setVerbPhrase(self.phraseFactory.createVerbPhrase("comment on"))
s.setObject("it")
s.setFeature(Feature.TENSE, Tense.PAST)
return s
def agreePhrase(self, name): # used by testRafael
s = self.phraseFactory.createClause()
s.setSubject(self.phraseFactory.createNounPhrase(name))
s.setVerbPhrase(self.phraseFactory.createVerbPhrase("agree with"))
s.setObject("it")
s.setFeature(Feature.TENSE, Tense.PAST)
return s
def disagreePhrase(self, name): # used by testRafael
s = self.phraseFactory.createClause()
s.setSubject(self.phraseFactory.createNounPhrase(name))
s.setVerbPhrase(self.phraseFactory.createVerbPhrase("disagree with"))
s.setObject("it")
s.setFeature(Feature.TENSE, Tense.PAST)
return s
@unittest.skip('aggregation not implemented')
def testWkipedia(self):
# test code fragments in wikipedia realisation
subject = self.phraseFactory.createNounPhrase("the", "woman")
subject.setPlural(True)
sentence = self.phraseFactory.createClause(subject, "smoke")
sentence.setFeature(Feature.NEGATED, True)
self.assertEqual("The women do not smoke.",
realiser.realiseSentence(sentence))
# aggregation
s1 = self.phraseFactory.createClause("the man", "be", "hungry")
s2 = self.phraseFactory.createClause("the man", "buy", "an apple")
result = ClauseCoordinationRule().apply(s1, s2)
self.assertEqual("The man is hungry and buys an apple.",
realiser.realiseSentence(result))
def testLean(self):
# A Lean's test
sentence = self.phraseFactory.createClause()
sentence.setVerb("be")
sentence.setObject("a ball")
sentence.setFeature(Feature.INTERROGATIVE_TYPE,
InterrogativeType.WHAT_SUBJECT)
self.assertEqual("What is a ball?",
self.realiser.realiseSentence(sentence))
sentence = self.phraseFactory.createClause()
sentence.setVerb("be")
object = self.phraseFactory.createNounPhrase("example")
object.setPlural(True)
object.addModifier("of jobs")
sentence.setFeature(Feature.INTERROGATIVE_TYPE,
InterrogativeType.WHAT_SUBJECT)
sentence.setObject(object)
self.assertEqual("What are examples of jobs?",
self.realiser.realiseSentence(sentence))
p = self.phraseFactory.createClause()
sub1 = self.phraseFactory.createNounPhrase("Mary")
sub1.setFeature(LexicalFeature.GENDER, Gender.FEMININE)
sub1.setFeature(Feature.PRONOMINAL, True)
sub1.setFeature(Feature.PERSON, Person.FIRST)
p.setSubject(sub1)
p.setVerb("chase")
p.setObject("the monkey")
output2 = self.realiser.realiseSentence(p)
self.assertEqual("I chase the monkey.", output2)
test = self.phraseFactory.createClause()
subject = self.phraseFactory.createNounPhrase("Mary")
subject.setFeature(Feature.PRONOMINAL, True)
subject.setFeature(Feature.PERSON, Person.SECOND)
test.setSubject(subject)
test.setVerb("cry")
test.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHY)
test.setFeature(Feature.TENSE, Tense.PRESENT)
self.assertEqual("Why do you cry?",
self.realiser.realiseSentence(test))
test = self.phraseFactory.createClause()
subject = self.phraseFactory.createNounPhrase("Mary")
subject.setFeature(Feature.PRONOMINAL, True)
subject.setFeature(Feature.PERSON, Person.SECOND)
test.setSubject(subject)
test.setVerb("be")
test.setObject("crying")
test.setFeature(Feature.INTERROGATIVE_TYPE, InterrogativeType.WHY)
test.setFeature(Feature.TENSE, Tense.PRESENT)
self.assertEqual("Why are you crying?",
self.realiser.realiseSentence(test))
def testKalijurand(self):
# K Kalijurand's test
lemma = "walk"
word = self.lexicon.lookupWord(lemma, LexicalCategory.VERB)
inflectedWord = InflectedWordElement(word)
inflectedWord.setFeature(Feature.FORM, Form.PAST_PARTICIPLE)
form = self.realiser.realise(inflectedWord).getRealisation()
self.assertEqual("walked", form)
inflectedWord = InflectedWordElement(word)
inflectedWord.setFeature(Feature.PERSON, Person.THIRD)
form = self.realiser.realise(inflectedWord).getRealisation()
self.assertEqual("walks", form)
def testLay(self):
# Richard Lay's test
lemma = "slap"
word = self.lexicon.lookupWord(lemma, LexicalCategory.VERB)
inflectedWord = InflectedWordElement(word)
inflectedWord.setFeature(Feature.FORM, Form.PRESENT_PARTICIPLE)
form = self.realiser.realise(inflectedWord).getRealisation()
self.assertEqual("slapping", form)
v = self.phraseFactory.createVerbPhrase("slap")
v.setFeature(Feature.PROGRESSIVE, True)
progressive = self.realiser.realise(v).getRealisation()
self.assertEqual("is slapping", progressive)
