def test_predicate_two_objects_second_obj_is_never_pronoun(self):
random.seed(456)
verb_list = [
VerbGroup(verb=Verb('bring'),
preposition=BasicWord.preposition('to'),
objects=2,
particle=None),
VerbGroup(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_init_verbs(self):
verbs = [{
'verb': 'take',
'irregular_past': 'took',
'objects': 2,
'particle': 'away',
'preposition': 'with'
}, {
'verb': 'play',
'irregular_past': '',
'objects': 1,
'particle': '',
'preposition': ''
}]
lists = WordLists(verbs=verbs)
expected_verbs = [
VerbGroup(verb=Verb('take', 'took'),
preposition=BasicWord.preposition('with'),
particle=BasicWord.particle('away'),
objects=2),
VerbGroup(verb=Verb('play'),
preposition=None,
particle=None,
objects=1)
]
self.assert_unordered_lists(lists.verbs, expected_verbs)
self.assertEqual(lists.nouns, [])
def setUp(self):
self.countable = [Noun('dog'), Noun('cat'), Noun('pig'), Noun('frog')]
self.uncountable = [
Noun('water'),
Noun('rice'),
Noun('milk'),
Noun('sand')
]
self.verbs = [
VerbGroup(verb=Verb('eat'),
preposition=None,
objects=1,
particle=None),
VerbGroup(verb=Verb('give'),
preposition=None,
objects=2,
particle=None),
VerbGroup(verb=Verb('jump'),
preposition=BasicWord.preposition('over'),
objects=1,
particle=None),
VerbGroup(verb=Verb('lend'),
preposition=BasicWord.preposition('to'),
objects=2,
particle=None),
]
self.generator = RandomSentences(self.verbs,
self.countable + self.uncountable)
def setUp(self):
self.countable = [Noun('dog'), Noun('cat'), Noun('pig'), Noun('frog')]
self.uncountable = [
Noun('water'),
Noun('rice'),
Noun('milk'),
Noun('sand')
]
self.verbs = [
VerbGroup(verb=Verb('eat'),
preposition=None,
objects=1,
particle=None),
VerbGroup(verb=Verb('give'),
preposition=None,
objects=2,
particle=None),
VerbGroup(verb=Verb('jump'),
preposition=BasicWord.preposition('over'),
objects=1,
particle=None),
VerbGroup(verb=Verb('give'),
preposition=BasicWord.preposition('to'),
objects=2,
particle=None),
]
self.rp = RandomParagraph(0.2, self.verbs,
self.countable + self.uncountable)
self.raw_tags = Tags([StatusTag.RAW])
def test_eq_true(self):
verb = Verb('go')
objects = 1
preposition = None
particle = BasicWord.particle('x')
to_test = VerbGroup(verb, preposition, particle, objects)
self.assertEqual(to_test, VerbGroup(verb, preposition, particle, objects))
def setUp(self):
self.config_state = {
'error_probability': 1.0,
'noun_errors': True,
'pronoun_errors': True,
'verb_errors': True,
'is_do_errors': True,
'preposition_transpose_errors': True,
'punctuation_errors': True,
'tense': 'simple_present',
'probability_plural_noun': 1.0,
'probability_negative_verb': 1.0,
'probability_pronoun': 1.0,
'paragraph_type': 'chain',
'subject_pool': 1,
'paragraph_size': 1,
}
self.verbs = [
VerbGroup(Verb('go'), BasicWord.preposition('with'),
BasicWord.particle('away'), 1),
VerbGroup(Verb('eat'), None, None, 1)
]
self.countable_nouns = [Noun('dog'), Noun('cat')]
self.uncountable_nouns = [
Noun.uncountable_noun('water'),
Noun.uncountable_noun('air').definite()
]
self.static_nouns = [
Noun.proper_noun('Joe'),
Noun.proper_noun('The Dude')
]
self.word_lists = DummyWordLists(nouns=self.countable_nouns,
verbs=self.verbs)
def test_assign_objects_no_objects_particle_or_preposition(self):
verb_group = VerbGroup(verb=Verb('chill'),
preposition=BasicWord.preposition('out'),
objects=0,
particle=None)
self.assertEqual(
assign_objects(verb_group, []),
[Verb('chill'), BasicWord.preposition('out')])
verb_group = VerbGroup(verb=Verb('run'),
preposition=None,
objects=0,
particle=BasicWord.particle('away'))
self.assertEqual(assign_objects(verb_group, []),
[Verb('run'), BasicWord.particle('away')])
def test_create_chain_paragraph_loop_safety_finally_returns_paragraph_with_repeat_words(
self):
random.seed(4564)
verb_list = [
VerbGroup(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)
sentences = [
Sentence(
[Noun('bob'),
Verb('give'),
Noun('joe'),
Noun('bob'), PERIOD]),
Sentence(
[Noun('bob'),
Verb('give'),
Noun('bob'),
Noun('joe'), PERIOD]),
Sentence(
[Noun('joe'),
Verb('give'),
Noun('bob'),
Noun('joe'), PERIOD]),
]
expected = Paragraph(sentences, self.raw_tags)
self.assertEqual(expected, paragraph)
def test_assign_objects_one_object_no_particle_no_preposition(self):
verb_group = VerbGroup(verb=Verb('like'),
preposition=None,
objects=1,
particle=None)
self.assertEqual(assign_objects(verb_group, [Noun('dog')]),
[Verb('like'), Noun('dog')])
def test_sentence_particle(self):
random.seed(47)
nouns = [Noun('dog')]
verbs = [
VerbGroup(verb=Verb('pick'),
objects=1,
preposition=None,
particle=BasicWord.particle('up'))
]
generator = RandomSentences(verbs, nouns)
subj = HE
sentence = generator.sentence(subj, p_pronoun=1.0)
expected = Sentence(
[HE, Verb('pick'), US,
BasicWord.particle('up'), PERIOD])
self.assertEqual(sentence, expected)
sentence = generator.sentence(subj, p_pronoun=0.0)
expected = Sentence(
[HE,
Verb('pick'),
BasicWord.particle('up'),
Noun('dog'), PERIOD])
self.assertEqual(sentence, expected)
def test_eq_false(self):
verb = Verb('go')
objects = 1
preposition = None
particle = BasicWord.particle('x')
to_test = VerbGroup(verb, preposition, particle, objects)
new_verb = Verb('z')
new_objects = 2
new_preposition = BasicWord.preposition('x')
new_particle = BasicWord.particle('y')
self.assertNotEqual(to_test, VerbGroup(new_verb, preposition, particle, objects))
self.assertNotEqual(to_test, VerbGroup(verb, new_preposition, particle, objects))
self.assertNotEqual(to_test, VerbGroup(verb, preposition, new_particle, objects))
self.assertNotEqual(to_test, VerbGroup(verb, preposition, particle, new_objects))
def test_sentence_particle_preposition(self):
random.seed(2743)
nouns = [Noun('dog'), Noun('cat')]
verbs = [
VerbGroup(verb=Verb('pick'),
objects=2,
preposition=BasicWord.preposition('with'),
particle=BasicWord.particle('up'))
]
generator = RandomSentences(verbs, nouns)
subj = HE
sentence = generator.sentence(subj, p_pronoun=1.0)
expected = Sentence([
HE,
Verb('pick'), THEM,
BasicWord.particle('up'),
BasicWord.preposition('with'),
Noun('cat'), PERIOD
])
self.assertEqual(sentence, expected)
sentence = generator.sentence(subj, p_pronoun=0.0)
expected = Sentence([
HE,
Verb('pick'),
BasicWord.particle('up'),
Noun('cat'),
BasicWord.preposition('with'),
Noun('dog'), EXCLAMATION
])
self.assertEqual(sentence, expected)
def test_assign_objects_two_objects_no_particle_no_preposition(self):
verb_group = VerbGroup(verb=Verb('show'),
preposition=None,
objects=2,
particle=None)
self.assertEqual(
assign_objects(verb_group, [Noun('dog'), Noun('cat')]),
[Verb('show'), Noun('dog'), Noun('cat')])
def test_init_with_values(self):
verb = Verb('go')
preposition = BasicWord.preposition('with')
particle = BasicWord.particle('away')
to_test = VerbGroup(
verb=verb,
preposition=preposition,
particle=particle,
objects=2)
self.assertEqual(to_test.verb, verb)
self.assertEqual(to_test.preposition, preposition)
self.assertEqual(to_test.particle, particle)
self.assertEqual(to_test.objects, 2)
def test_init_with_none_values(self):
verb = Verb('go')
objects = 0
to_test = VerbGroup(
verb=verb,
preposition=None,
particle=None,
objects=objects
)
self.assertEqual(to_test.verb, verb)
self.assertIsNone(to_test.preposition)
self.assertIsNone(to_test.particle)
self.assertEqual(to_test.objects, objects)
def test_create_pool_paragraph_is_correct_length(self):
verb_list = [
VerbGroup(verb=Verb('play'),
preposition=None,
objects=0,
particle=None)
]
rp = RandomParagraph(0.2, verb_list, self.countable + self.uncountable)
for length in range(3, 11):
pool = length - 2
answer = rp.create_pool_paragraph(pool, length)
self.assertEqual(len(answer), length)
def test_predicate_two_objects_the_same_when_no_other_options(self):
random.seed(101)
verb_list = [
VerbGroup(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_assign_objects_one_object_particle(self):
verb_group = VerbGroup(verb=Verb('pick'),
preposition=None,
objects=1,
particle=BasicWord.particle('up'))
self.assertEqual(
assign_objects(verb_group, [IT]),
[Verb('pick'), IT, BasicWord.particle('up')])
self.assertEqual(
assign_objects(verb_group, [Noun('dog')]),
[Verb('pick'), BasicWord.particle('up'),
Noun('dog')])
def test_assign_objects_one_object_preposition(self):
verb_group = VerbGroup(verb=Verb('play'),
preposition=BasicWord.preposition('with'),
objects=1,
particle=None)
self.assertEqual(
assign_objects(verb_group, [IT]),
[Verb('play'), BasicWord.preposition('with'), IT])
self.assertEqual(
assign_objects(verb_group, [Noun('dog')]),
[Verb('play'),
BasicWord.preposition('with'),
Noun('dog')])
def test_predicate_p_pronoun_one_or_greater(self):
verbs = [
VerbGroup(verb=Verb('eat'),
objects=1,
particle=None,
preposition=None)
]
generator = RandomSentences(verbs, self.countable)
pronoun = generator.predicate(1.0)[1]
self.assertIsInstance(pronoun, Pronoun)
pronoun = generator.predicate(1.1)[1]
self.assertIsInstance(pronoun, Pronoun)
def test_predicate_p_pronoun_zero_or_less(self):
verbs = [
VerbGroup(verb=Verb('eat'),
objects=1,
particle=None,
preposition=None)
]
generator = RandomSentences(verbs, self.countable)
noun = generator.predicate(0.0)[1]
self.assertIsInstance(noun, Noun)
noun = generator.predicate(-0.1)[1]
self.assertIsInstance(noun, Noun)
def test_create_chain_paragraph_pronouns(self):
verb_list = [
VerbGroup(verb=Verb('eat'),
preposition=None,
objects=1,
particle=None)
]
rp = RandomParagraph(1.0, verb_list, self.countable + self.uncountable)
answer = rp.create_chain_paragraph(10)
for back_index, sentence in enumerate(answer.sentence_list()[1:]):
previous_obj = answer.get_sentence(back_index).get(-2)
current_subj = sentence.get(0)
self.assertEqual(previous_obj.subject(), current_subj)
def test_sentence_p_pronoun_lte_zero(self):
verbs = [
VerbGroup(verb=Verb('eat'),
objects=1,
preposition=None,
particle=None)
]
generator = RandomSentences(verbs, self.countable)
subject = HE
obj = generator.sentence(subject, p_pronoun=0.0).get(2)
self.assertIsInstance(obj, Noun)
obj = generator.sentence(subject, p_pronoun=-0.1).get(2)
self.assertIsInstance(obj, Noun)
def test_makes_copy_of_input_list(self):
random.seed(148)
for index in range(4):
self.countable[index] = Noun('oops')
self.uncountable[index] = Noun('oops')
self.verbs[index] = VerbGroup(Verb('a'), BasicWord('b'),
BasicWord('c'), 4)
answer = self.generator.predicate()
expected = [
Verb('lend'),
Noun('dog'),
BasicWord.preposition('to'),
Noun('milk'), PERIOD
]
self.assertEqual(answer, expected)
def test_assign_objects_two_objects_preposition(self):
verb_group = VerbGroup(verb=Verb('bring'),
preposition=BasicWord.preposition('to'),
objects=2,
particle=None)
self.assertEqual(assign_objects(verb_group, [HIM, IT]),
[Verb('bring'), HIM,
BasicWord.preposition('to'), IT])
self.assertEqual(
assign_objects(verb_group, [Noun('cat'), Noun('dog')]), [
Verb('bring'),
Noun('cat'),
BasicWord.preposition('to'),
Noun('dog')
])
def test_predicate_p_pronoun_between_zero_and_one(self):
verbs = [
VerbGroup(verb=Verb('eat'),
objects=1,
particle=None,
preposition=None)
]
generator = RandomSentences(verbs, self.countable)
random.seed(347859)
nouns = [0, 1, 4, 5, 6]
for iteration in range(10):
word = generator.predicate(0.5)[1]
if iteration in nouns:
self.assertIsInstance(word, Noun)
else:
self.assertIsInstance(word, Pronoun)
def test_predicate_two_objects_are_never_the_same(self):
verb_list = [
VerbGroup(verb=Verb('give'),
preposition=None,
objects=2,
particle=None),
]
generator = RandomSentences(verb_list, [Noun('dog'), Noun('water')])
test_membership = (Noun('dog'), Noun('water'))
for _ in range(100):
predicate = generator.predicate(0.0)
noun_1 = predicate[-2]
noun_2 = predicate[-3]
self.assertNotEqual(noun_1, noun_2)
self.assertIn(noun_1, test_membership)
self.assertIn(noun_2, test_membership)
def test_create_chain_paragraph_assigns_random_subj_if_no_obj(self):
random.seed(11)
verb_list = [
VerbGroup(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)
sentences = [
Sentence([Noun('sand'), Verb('jump'), EXCLAMATION]),
Sentence([Noun('frog'), Verb('jump'), EXCLAMATION]),
Sentence([Noun('pig'), Verb('jump'), PERIOD])
]
expected = Paragraph(sentences, self.raw_tags)
self.assertEqual(expected, answer)
def _generate_verb_group(verb_json):
"""
:param verb_json: keys='verb', 'irregular_past', 'objects', 'preposition', 'particle'
:return: VerbGroup
"""
verb = Verb(verb_json['verb'], irregular_past=verb_json['irregular_past'])
objects = verb_json['objects']
preposition = BasicWord.preposition(verb_json['preposition'])
particle = BasicWord.particle((verb_json['particle']))
if preposition.value == '':
preposition = None
if particle.value == '':
particle = None
return VerbGroup(verb=verb, objects=objects, preposition=preposition, particle=particle)
def test_sentence_p_pronoun_between_one_and_zero(self):
random.seed(38754)
verbs = [
VerbGroup(verb=Verb('eat'),
objects=1,
preposition=None,
particle=None)
]
generator = RandomSentences(verbs, self.countable)
subject = HE
nouns = [2, 3, 6, 9]
for iteration in range(10):
obj = generator.sentence(subject, p_pronoun=0.5).get(2)
if iteration in nouns:
self.assertIsInstance(obj, Noun)
else:
self.assertIsInstance(obj, Pronoun)
