def test_random_sentences_sentence_with_phrasal_verb_one_obj_and_preposition(
self):
random.seed(456123)
verb_list = [{
'verb': Verb('put'),
'preposition': BasicWord.preposition('with'),
'objects': 1,
'particle': BasicWord.particle('up')
}]
generator = RandomSentences(verb_list,
self.countable + self.uncountable)
answer = generator.sentence()
expected = [
Noun('pig'),
Verb('put'),
BasicWord.particle('up'),
BasicWord.preposition('with'), YOU, PERIOD
]
self.assertEqual(answer, expected)
answer = generator.sentence()
expected = [
Noun('water'),
Verb('put'),
BasicWord.particle('up'),
BasicWord.preposition('with'),
Noun('pig'), EXCLAMATION
]
self.assertEqual(answer, expected)
def test_generate_paragraph_plural_countable_noun(self):
raw_paragraph = [[Noun('cat'), Verb('grab'), Noun('cat'), EXCLAMATION]]
grammarizer = Grammarizer(raw_paragraph, probability_negative_verb=0.0, probability_plural_noun=1.0)
paragraph = grammarizer.generate_paragraph()
expected = [[Noun('Cats', '', 'cat', tags=self.plural), Verb('grab'),
Noun('the cats', '', 'cat', tags=self.definite_plural), EXCLAMATION]]
self.assertEqual(paragraph, expected)
def test_grammarizer_set_nouns(self):
paragraph = [
[Noun.uncountable_noun('money'), Verb('grab'), Noun('witch'), EXCLAMATION],
[Noun('witch'), Verb('play'), Noun('watch'), PERIOD]
]
grammarizer = Grammarizer(paragraph, probability_plural_noun=0.5)
random.seed(10)
grammarizer.set_nouns()
noun_info = {
Noun('watch'): {'plural': True, 'definite': False, 'countable': True},
Noun('witch'): {'plural': False, 'definite': False, 'countable': True},
Noun.uncountable_noun('money'): {'plural': False, 'definite': False, 'countable': False},
}
self.assertEqual(grammarizer.noun_info, noun_info)
grammarizer.set_nouns()
noun_info = {
Noun('watch'): {'plural': True, 'definite': False, 'countable': True},
Noun('witch'): {'plural': False, 'definite': False, 'countable': True},
Noun.uncountable_noun('money'): {'plural': False, 'definite': False, 'countable': False},
}
self.assertEqual(grammarizer.noun_info, noun_info)
grammarizer.set_nouns()
noun_info = {
Noun('watch'): {'plural': False, 'definite': False, 'countable': True},
Noun('witch'): {'plural': False, 'definite': False, 'countable': True},
Noun.uncountable_noun('money'): {'plural': False, 'definite': False, 'countable': False},
}
self.assertEqual(grammarizer.noun_info, noun_info)
def test_create_chain_paragraph_loop_safety_finally_returns_paragraph_with_repeat_words(
self):
random.seed(20)
verb_list = [{
'verb': Verb('give'),
'preposition': None,
'objects': 2,
'particle': None
}]
repeats = RandomParagraph(0.0, verb_list, [Noun('joe'), Noun('bob')])
paragraph = repeats.create_chain_paragraph(3)
expected = [
[Noun('joe'),
Verb('give'),
Noun('joe'),
Noun('bob'), PERIOD],
[Noun('bob'),
Verb('give'),
Noun('bob'),
Noun('joe'), EXCLAMATION],
[Noun('joe'),
Verb('give'),
Noun('bob'),
Noun('joe'), PERIOD],
]
self.assertEqual(expected, paragraph)
def test_two_objects_second_obj_is_never_pronoun(self):
random.seed(456)
verb_list = [
{
'verb': Verb('bring'),
'preposition': BasicWord.preposition('to'),
'objects': 2,
'particle': None
},
{
'verb': Verb('give'),
'preposition': None,
'objects': 2,
'particle': None
},
]
generator = RandomSentences(verb_list,
self.countable + self.uncountable)
answer = generator.predicate(1.0)
self.assertEqual(answer, [Verb('give'), HER, Noun('dog'), EXCLAMATION])
answer = generator.predicate(1.0)
self.assertEqual(answer, [
Verb('bring'), ME,
BasicWord.preposition('to'),
Noun('sand'), PERIOD
])
answer = generator.predicate(1.0)
self.assertEqual(
answer,
[Verb('give'), HIM, Noun('milk'), EXCLAMATION])
def test_equality_true_false_by_tags(self):
test = Verb('a', 'b', 'c', tags=self.past)
equal = Verb('a', 'b', 'c', tags=self.past)
not_equal = Verb('a', 'b', 'c', tags=self.negative_past)
self.assertEqual(test, equal)
self.assertNotEqual(test, not_equal)
def test_third_person_special_case(self):
verb = Verb('have', 'had')
past = verb.past_tense()
expected = Verb('has', 'had', 'have', tags=self.third_person)
self.assertEqual(verb.third_person(), expected)
self.assertEqual(past.third_person(), expected)
def test_create_pool_paragraph_repeats_very_very_edge_case(self):
random.seed(20)
verb_list = [{
'verb': Verb('give'),
'preposition': None,
'objects': 2,
'particle': None
}]
repeats = RandomParagraph(0.0, verb_list, [Noun('cat'), Noun('water')])
answer = repeats.create_pool_paragraph(2, 2)
expected = [[
Noun('water'),
Verb('give'),
Noun('cat'),
Noun('water'), PERIOD
], [Noun('cat'),
Verb('give'),
Noun('cat'),
Noun('water'), PERIOD]]
self.assertEqual(answer, expected)
no_prepositions = [
verb_dict for verb_dict in self.verbs
if verb_dict['preposition'] is None
]
no_repeats = RandomParagraph(0.0, no_prepositions,
[Noun('cat'), Noun('water')])
answer = no_repeats.create_pool_paragraph(2, 100)
for sentence in answer:
self.assertEqual(len(sentence), 4)
self.assertNotEqual(sentence[0], sentence[2])
def test_assign_preposition(self):
random.seed(1234)
verb_list = [{
'verb': Verb('jump'),
'preposition': BasicWord.preposition('on'),
'objects': 1,
'particle': None
}]
generator = RandomSentences(verb_list,
self.countable + self.uncountable)
answer = generator.sentence()
self.assertEqual(answer, [
Noun('sand'),
Verb('jump'),
BasicWord.preposition('on'), US, PERIOD
])
answer = generator.sentence()
expected = [
Noun('cat'),
Verb('jump'),
BasicWord.preposition('on'),
Noun('frog'), PERIOD
]
self.assertEqual(answer, expected)
def test_create_pool_paragraph_output(self):
random.seed(3)
paragraph = self.rp.create_pool_paragraph(2, 5)
expected = [[Noun('pig'),
Verb('eat'),
Noun('sand'), PERIOD],
[
Noun('pig'),
Verb('give'),
Noun('cat'),
BasicWord.preposition('to'),
Noun('dog'), PERIOD
],
[
Noun('sand'),
Verb('jump'),
BasicWord.preposition('over'),
Noun('milk'), EXCLAMATION
], [Noun('sand'), Verb('eat'), HIM, PERIOD],
[
Noun('sand'),
Verb('jump'),
BasicWord.preposition('over'),
Noun('milk'), EXCLAMATION
]]
self.assertEqual(paragraph, expected)
def test_assign_preposition_insert_preposition_true(self):
random.seed(7890)
verb_list = [{
'verb': Verb('bring'),
'preposition': BasicWord.preposition('to'),
'objects': 2,
'particle': None
}]
generator = RandomSentences(verb_list,
self.countable + self.uncountable)
answer = generator.sentence()
self.assertEqual(answer, [
Noun('milk'),
Verb('bring'),
Noun('water'),
BasicWord.preposition('to'),
Noun('rice'), EXCLAMATION
])
answer = generator.sentence()
self.assertEqual(answer, [
Noun('water'),
Verb('bring'),
Noun('dog'),
BasicWord.preposition('to'),
Noun('milk'), PERIOD
])
def test_get_non_proper_nouns_proper_nouns(self):
raw_paragraph = [
[Noun.proper_noun('NASA'), Verb('grab'), Noun.proper_noun('Joe'), EXCLAMATION],
[Noun.proper_noun('the Things', plural=True), Verb('cut', 'cut'), Noun.proper_noun('Bob'), PERIOD],
[Pronoun.IT, Verb('have', 'had'), Pronoun.THEM, PERIOD]
]
self.assertEqual(get_non_proper_nouns(raw_paragraph), [])
def test_get_non_proper_nouns_no_nouns(self):
raw_paragraph = [
[Pronoun.I, Verb('grab'), Pronoun.YOU, EXCLAMATION],
[Pronoun.WE, Verb('cut', 'cut'), Pronoun.IT, PERIOD],
[Pronoun.IT, Verb('have', 'had'), Pronoun.THEM, PERIOD]
]
self.assertEqual(get_non_proper_nouns(raw_paragraph), [])
def test_equality_true_false_by_irregular_past(self):
test = Verb('a', 'b', 'c', tags=self.past)
equal = Verb('a', 'b', 'c', tags=self.past)
not_equal = Verb('a', 'x', 'c', tags=self.past)
self.assertEqual(test, equal)
self.assertNotEqual(test, not_equal)
def test_random_sentences_sentence_with_phrasal_verb_two_obj_and_preposition(
self):
random.seed(789)
verb_list = [{
'verb': Verb('throw'),
'preposition': BasicWord.preposition('for'),
'objects': 2,
'particle': BasicWord.particle('away')
}]
generator = RandomSentences(verb_list,
self.countable + self.uncountable)
answer = generator.sentence()
expected = [
Noun('dog'),
Verb('throw'), US,
BasicWord.particle('away'),
BasicWord.preposition('for'),
Noun('water'), EXCLAMATION
]
self.assertEqual(answer, expected)
answer = generator.sentence()
expected = [
Noun('rice'),
Verb('throw'),
BasicWord.particle('away'),
Noun('water'),
BasicWord.preposition('for'),
Noun('frog'), PERIOD
]
self.assertEqual(answer, expected)
def test_assign_objects_no_objects_no_particle_no_preposition(self):
verb_dict = {
'verb': Verb('chill'),
'preposition': None,
'objects': 0,
'particle': None
}
self.assertEqual(assign_objects(verb_dict, []), [Verb('chill')])
def test_past_tense_past_verb(self):
verb = Verb('played', '', 'play', tags=self.past)
negative = verb.negative()
self.assertNotEqual(verb, negative)
self.assertEqual(verb.past_tense(), verb)
self.assertEqual(verb.past_tense().past_tense(), verb)
self.assertEqual(negative.past_tense(), negative)
self.assertEqual(negative.past_tense().past_tense(), negative)
def test_assign_objects_one_object_no_particle_no_preposition(self):
verb_dict = {
'verb': Verb('like'),
'preposition': None,
'objects': 1,
'particle': None
}
self.assertEqual(assign_objects(verb_dict, [Noun('dog')]),
[Verb('like'), Noun('dog')])
def test_is_word_in_sentence_other(self):
sentence = [BasicWord('tom'), Verb('dick'), Noun('harry')]
self.assertTrue(is_word_in_sentence(BasicWord('tom'), sentence))
self.assertTrue(is_word_in_sentence(Verb('dick'), sentence))
self.assertTrue(is_word_in_sentence(Noun('harry'), sentence))
self.assertFalse(is_word_in_sentence(Noun('tom'), sentence))
self.assertFalse(is_word_in_sentence(BasicWord('dick'), sentence))
self.assertFalse(is_word_in_sentence(Verb('harry'), sentence))
def test_assign_objects_two_objects_no_particle_no_preposition(self):
verb_dict = {
'verb': Verb('show'),
'preposition': None,
'objects': 2,
'particle': None
}
self.assertEqual(
assign_objects(verb_dict, [Noun('dog'), Noun('cat')]),
[Verb('show'), Noun('dog'), Noun('cat')])
def test_negative_with_negative_verb(self):
verb = Verb("don't play", '', 'play', tags=self.negative)
self.assertEqual(verb.negative(), verb)
self.assertEqual(verb.negative().negative(), verb)
verb = Verb("doesn't play", '', 'play', tags=self.negative_third_person)
self.assertEqual(verb.negative(), verb)
verb = Verb("didn't play", '', 'play', tags=self.negative_past)
self.assertEqual(verb.negative(), verb)
def test_generate_paragraph_uncountable_noun(self):
raw_paragraph = [
[Noun.uncountable_noun('water'), Verb('grab'), Noun.uncountable_noun('water'), PERIOD]
]
grammarizer = Grammarizer(raw_paragraph, probability_negative_verb=0.0, probability_plural_noun=1.0)
paragraph = grammarizer.generate_paragraph()
expected = [[
Noun('Water', '', 'water', tags=self.uncountable), Verb('grabs', '', 'grab', tags=self.third_person),
Noun('the water', '', 'water', tags=self.definite_uncountable), PERIOD
]]
self.assertEqual(paragraph, expected)
def test_get_non_proper_nouns_with_nouns(self):
paragraph = [
[Noun('money'), Verb('grab'), Noun('tea'), EXCLAMATION],
[Noun('tea'), Verb('ride', 'rode'), Noun('apple'), PERIOD],
[Noun('apple'), Verb('surprise'), Noun('gold'), PERIOD],
[Noun('gold'), Verb('cut', 'cut'), Noun.proper_noun('Joe'), PERIOD],
[Pronoun.IT, Verb('have', 'had'), Noun('watch'), PERIOD]
]
self.assertEqual(get_non_proper_nouns(paragraph),
[Noun('money'), Noun('tea'), Noun('apple'), Noun('gold'), Noun('watch')])
def test_generate_paragraph_present_tense_third_person_negative(self):
raw_paragraph = [
[Noun.uncountable_noun('water'), Verb('grab'), Noun.uncountable_noun('water'), EXCLAMATION],
[Noun('cat'), Verb('grab'), Noun('cat'), EXCLAMATION],
[Noun.proper_noun('Joe'), Verb('grab'), Noun('cat')]
]
grammarizer = Grammarizer(raw_paragraph, probability_negative_verb=1.0, probability_plural_noun=0.0)
paragraph = grammarizer.generate_paragraph()
target_verb = Verb("doesn't grab", '', 'grab', tags=self.negative_third_person)
for sentence in paragraph:
self.assertEqual(sentence[1], target_verb)
def test_grammarizer_noun_info_property_is_copy(self):
paragraph = [
[Noun('money'), Verb('grab'), Noun('tea'), EXCLAMATION],
[Pronoun.IT, Verb('have', 'had'), Noun('watch'), PERIOD]
]
grammarizer = Grammarizer(paragraph)
info_1 = grammarizer.noun_info
info_2 = grammarizer.noun_info
self.assertEqual(info_1, info_2)
self.assertIsNot(info_1, info_2)
self.assertIsNot(info_1[Noun('money')], info_2[Noun('money')])
def test_requires_third_person(self):
answer = [it, Verb('steal', 'stole'), her, exclamation]
self.assertTrue(requires_third_person(answer))
answer = [Noun('teacher', ''), Verb('take', 'took'), me, period]
self.assertTrue(requires_third_person(answer))
answer[0] = answer[0].plural()
self.assertFalse(requires_third_person(answer))
answer[0] = you
self.assertFalse(requires_third_person(answer))
def test_generate_paragraph_returns_sentences_with_capitals(self):
paragraph = [
[Noun('money'), Verb('grab'), Noun('tea'), EXCLAMATION],
[Noun('tea'), Verb('ride', 'rode', ''), Noun('apple'), PERIOD],
[Noun('apple'), Verb('surprise'), Noun('gold'), PERIOD],
[Noun.proper_noun('the Dude'), Verb('cut', 'cut', ''), Pronoun.IT, PERIOD],
[Pronoun.IT, Verb('have', 'had', ''), Noun('watch'), PERIOD]
]
grammarizer = Grammarizer(paragraph)
paragraph = grammarizer.generate_paragraph()
for sentence in paragraph:
self.assertIn(sentence[0].value[0], string.ascii_uppercase)
def test_grammarizer_reset_definite_nouns(self):
paragraph = [
[Noun('money'), Verb('grab'), Noun('tea'), EXCLAMATION],
[Pronoun.IT, Verb('have', 'had'), Noun('watch'), PERIOD]
]
grammarizer = Grammarizer(paragraph)
grammarizer.generate_paragraph()
for noun_dict in grammarizer.noun_info.values():
self.assertTrue(noun_dict['definite'])
grammarizer.reset_definite_nouns()
for noun_dict in grammarizer.noun_info.values():
self.assertFalse(noun_dict['definite'])
def test_two_objects_the_same_when_no_other_options(self):
random.seed(101)
verb_list = [{
'verb': Verb('give'),
'preposition': None,
'objects': 2,
'particle': None
}]
generator = RandomSentences(verb_list, [Noun('dog')])
self.assertEqual(
generator.predicate(),
[Verb('give'), Noun('dog'),
Noun('dog'), PERIOD])
def test_create_chain_paragraph_assigns_random_subj_if_no_obj(self):
random.seed(11)
verb_list = [{
'verb': Verb('jump'),
'preposition': None,
'objects': 0,
'particle': None
}]
rp = RandomParagraph(0.2, verb_list, self.countable + self.uncountable)
answer = rp.create_chain_paragraph(3)
expected = [[Noun('sand'), Verb('jump'), EXCLAMATION],
[Noun('frog'), Verb('jump'), EXCLAMATION],
[Noun('pig'), Verb('jump'), PERIOD]]
self.assertEqual(expected, answer)
