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 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 '-'
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)