def test_proper_noun_singular_class_method(self):
test_1 = Noun.proper_noun('Joe')
test_2 = Noun.proper_noun('Joe', plural=False)
expected = Noun('Joe', '', 'Joe', Tags([WordTag.PROPER]))
self.assertEqual(test_1, expected)
self.assertEqual(test_2, expected)
def test_init_reverts_countable_nouns_and_removes_tag(self):
original_sentences = [
Sentence([
Noun('x').plural(),
Noun('y'),
Noun.uncountable_noun('z'),
Noun.proper_noun('A', plural=True),
Noun.uncountable_noun('q').definite()
])
]
original_tags = Tags([StatusTag.HAS_PLURALS, StatusTag.RAW])
original_paragraph = Paragraph(original_sentences, original_tags)
pa = PluralsAssignment(original_paragraph)
self.assertEqual(original_paragraph.sentence_list(),
original_sentences)
self.assertEqual(original_paragraph.tags, original_tags)
expected = [
Sentence([
Noun('x'),
Noun('y'),
Noun.uncountable_noun('z'),
Noun.proper_noun('A', plural=True),
Noun.uncountable_noun('q').definite()
])
]
self.assertEqual(pa.raw.sentence_list(), expected)
self.assertEqual(pa.raw.tags, Tags([StatusTag.RAW]))
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_is_countable_noun_false(self):
self.assertFalse(is_countable_noun(BasicWord('dog')))
self.assertFalse(is_countable_noun(Noun.uncountable_noun('water')))
self.assertFalse(
is_countable_noun(Noun.proper_noun('Joe', plural=False)))
self.assertFalse(
is_countable_noun(Noun.proper_noun('the Joes', plural=True)))
def test_error_maker_noun_errors_p_error_gte_one(self):
random.seed(4758)
sentences = [
Sentence([Noun('a').definite(),
Noun.proper_noun('C')]),
Sentence([Noun('d').indefinite(),
Noun('e').plural()]),
Sentence([Noun.uncountable_noun('f')])
]
paragraph = Paragraph(sentences)
error_maker = ErrorMaker(paragraph)
error_paragraph = error_maker.noun_errors(1.0).get_paragraph()
expected = [
Sentence(
[Noun('a').indefinite(),
Noun.proper_noun('C').indefinite()]),
Sentence([Noun('d'), Noun('e').indefinite()]),
Sentence([Noun.uncountable_noun('f').indefinite()])
]
self.assertEqual(error_paragraph.sentence_list(), expected)
error_paragraph = error_maker.noun_errors(1.1).get_paragraph()
expected = [
Sentence([Noun('a'), Noun.proper_noun('C').definite()]),
Sentence([Noun('d'), Noun('e').indefinite()]),
Sentence([Noun.uncountable_noun('f').plural()])
]
self.assertEqual(error_paragraph.sentence_list(), expected)
def test_init_static_nouns(self):
static_nouns = [{
'noun': 'the Dude',
'is_plural': False
}, {
'noun': 'the Joneses',
'is_plural': True
}]
lists = WordLists(static=static_nouns)
expected_nouns = [
Noun.proper_noun('the Dude', plural=False),
Noun.proper_noun('the Joneses', plural=True)
]
self.assert_unordered_lists(expected_nouns, lists.nouns)
self.assertEqual(lists.verbs, [])
def test_to_basic_noun_does_not_remove_specific_tags(self):
original = Noun.proper_noun('Joe', plural=False)
self.assertEqual(original.to_basic_noun(), original)
self.assertEqual(original.capitalize().bold().to_basic_noun(),
original)
original = Noun.proper_noun('the Things', plural=True)
self.assertEqual(original.to_basic_noun(), original)
self.assertEqual(original.capitalize().bold().to_basic_noun(),
original)
original = Noun.uncountable_noun('water')
self.assertEqual(original.to_basic_noun(), original)
self.assertEqual(original.capitalize().bold().to_basic_noun(),
original)
self.assertEqual(original.definite().to_basic_noun(), original)
def test_indefinite_only_has_indefinite_tag(self):
uncountable = Noun.uncountable_noun('water')
self.assertEqual(uncountable.tags, Tags([WordTag.UNCOUNTABLE]))
proper = Noun.proper_noun('Joes', plural=True)
self.assertEqual(proper.tags, self.plural_proper)
self.assertEqual(uncountable.indefinite(),
Noun('a water', '', 'water', tags=self.indefinite))
self.assertEqual(proper.indefinite(),
Noun('a Joes', '', 'Joes', tags=self.indefinite))
def test_repr(self):
self.assertEqual(repr(Noun('bob')), "Noun('bob', '', 'bob', Tags([]))")
self.assertEqual(
repr(Noun.uncountable_noun('bob')),
"Noun('bob', '', 'bob', Tags([WordTag.UNCOUNTABLE]))")
self.assertEqual(
repr(Noun.proper_noun('Bob', plural=True)),
"Noun('Bob', '', 'Bob', Tags([WordTag.PLURAL, WordTag.PROPER]))")
self.assertEqual(repr(Noun('a', 'b', 'c', Tags([WordTag.PLURAL]))),
"Noun('a', 'b', 'c', Tags([WordTag.PLURAL]))")
def test_make_noun_error_proper_no_article(self):
random.seed(191)
noun = Noun.proper_noun('Joe')
definite = [1, 2, 6, 7, 8, 9]
for index in range(10):
to_test = make_noun_error(noun)
if index in definite:
self.assertEqual(
Noun('the Joe', '', 'Joe', tags=self.definite), to_test)
else:
self.assertEqual(
Noun('a Joe', '', 'Joe', tags=self.indefinite), to_test)
def test_get_countable_nouns(self):
sentence_list = [
Sentence(
[Noun.uncountable_noun('water'),
BasicWord('is'),
Noun('pig')]),
Sentence([Noun.proper_noun('Joe'),
Noun('pig'),
Noun('dog')])
]
paragraph = Paragraph(sentence_list)
self.assertEqual(get_countable_nouns(paragraph),
[Noun('pig'), Noun('dog')])
def test_make_noun_error_plural_proper(self):
random.seed(69167)
noun = Noun.proper_noun('Eds', plural=True).capitalize()
definite = [1, 5, 8, 9]
for index in range(10):
to_test = make_noun_error(noun)
if index in definite:
self.assertEqual(
Noun('the Eds', '', 'Eds', tags=self.definite_plural),
to_test)
else:
self.assertEqual(
Noun('an Eds', '', 'Eds', tags=self.indefinite), to_test)
def test_make_noun_error_proper_with_article(self):
random.seed(6541)
noun = Noun.proper_noun('the Dude').capitalize()
definite = [0, 1, 2, 7, 8, 9]
for index in range(10):
to_test = make_noun_error(noun)
if index in definite:
self.assertEqual(
Noun('the the Dude', '', 'the Dude', tags=self.definite),
to_test)
else:
self.assertEqual(
Noun('a the Dude', '', 'the Dude', tags=self.indefinite),
to_test)
def test_get_be_verb_past_tense_plural_subject(self):
plural_subj = [
Noun('cat').plural(),
Noun.proper_noun('the Joes', plural=True), Pronoun.YOU,
CapitalPronoun.YOU, Pronoun.WE, Pronoun.US, CapitalPronoun.WE,
CapitalPronoun.US, Pronoun.THEY, Pronoun.THEM, CapitalPronoun.THEY,
CapitalPronoun.THEM
]
for subj in plural_subj:
sentence = Sentence([subj, Verb('go').past_tense()])
self.assertEqual(get_be_verb(sentence), BeVerb.WERE)
sentence = Sentence([subj, Verb('go').negative().past_tense()])
self.assertEqual(get_be_verb(sentence), BeVerb.WERE_NOT)
def test_plural_does_not_change_a_plural_noun(self):
plural = Noun('dog').plural()
definite_plural = Noun('dog').definite().plural()
proper_plural = Noun.proper_noun('the Joneses', plural=True)
self.assertEqual(plural.plural(), plural)
self.assertEqual(plural.plural().plural().plural(), plural)
self.assertEqual(definite_plural.plural(), definite_plural)
self.assertEqual(definite_plural.plural().plural().plural(),
definite_plural)
self.assertEqual(proper_plural.plural(), proper_plural)
self.assertEqual(proper_plural.plural().plural().plural(),
proper_plural)
def test_get_be_verb_present_tense_singular_subject(self):
singular_subj = [
Noun('cat').definite(),
Noun('cat').indefinite(),
Noun.uncountable_noun('water'),
Noun.proper_noun('Joe'), Pronoun.HE, Pronoun.HIM, Pronoun.SHE,
Pronoun.HER, Pronoun.IT, CapitalPronoun.HE, CapitalPronoun.HIM,
CapitalPronoun.SHE, CapitalPronoun.HER, CapitalPronoun.IT
]
for subj in singular_subj:
sentence = Sentence([subj, Verb('go')])
self.assertEqual(get_be_verb(sentence), BeVerb.IS)
sentence = Sentence([subj, Verb('go').negative()])
self.assertEqual(get_be_verb(sentence), BeVerb.IS_NOT)
def test_get_countable_nouns_reverts_to_basic_nouns(self):
sentence_list = [
Sentence([
Noun.uncountable_noun('water'),
BasicWord('is'),
Noun('pig').plural().definite().capitalize()
]),
Sentence([
Noun.proper_noun('Joe'),
Noun('pig').indefinite(),
Noun('dog').plural()
])
]
paragraph = Paragraph(sentence_list)
self.assertEqual(get_countable_nouns(paragraph),
[Noun('pig'), Noun('dog')])
def test_error_maker_noun_errors_p_error_lte_zero(self):
sentences = [
Sentence([
Noun('a'),
Noun('b').plural(),
Noun.uncountable_noun('c'),
Noun.proper_noun('e')
])
]
paragraph = Paragraph(sentences)
error_maker = ErrorMaker(paragraph)
error_paragraph = error_maker.noun_errors(0.0).get_paragraph()
self.assertEqual(error_paragraph.sentence_list(), sentences)
error_paragraph = error_maker.noun_errors(-1.0).get_paragraph()
self.assertEqual(error_paragraph.sentence_list(), sentences)
def test_error_maker_noun_error_p_error_middle(self):
random.seed(475456)
sentences = [
Sentence([Noun('a').definite(),
Noun.proper_noun('C')]),
Sentence([Noun('d').indefinite(),
Noun('e').plural()])
]
paragraph = Paragraph(sentences)
error_maker = ErrorMaker(paragraph)
error_paragraph = error_maker.noun_errors(0.5).get_paragraph()
expected = [
sentences[0],
Sentence([Noun('d'), Noun('e').plural().indefinite()])
]
self.assertEqual(error_paragraph.sentence_list(), expected)
def test_make_noun_error_plural_proper_with_article(self):
random.seed(2559)
noun = Noun.proper_noun('the Joneses', plural=True).capitalize()
definite = [0, 1, 2, 8]
for index in range(10):
to_test = make_noun_error(noun)
if index in definite:
self.assertEqual(
Noun('the the Joneses',
'',
'the Joneses',
tags=self.definite_plural), to_test)
else:
self.assertEqual(
Noun('a the Joneses',
'',
'the Joneses',
tags=self.indefinite), to_test)
def test_init_all_types(self):
verbs = [{
'verb': 'play',
'irregular_past': '',
'preposition': '',
'particle': '',
'objects': 1
}]
countable = [{'noun': 'dog', 'irregular_plural': ''}]
uncountable = [{'noun': 'water', 'definite': False}]
static = [{'noun': 'Joe', 'is_plural': False}]
lists = WordLists(verbs=verbs,
countable=countable,
uncountable=uncountable,
static=static)
expected_verbs = [VerbGroup(Verb('play'), None, None, 1)]
expected_nouns = [
Noun('dog'),
Noun.uncountable_noun('water'),
Noun.proper_noun('Joe')
]
self.assert_unordered_lists(lists.verbs, expected_verbs)
self.assert_unordered_lists(lists.nouns, expected_nouns)
def test_proper_noun_plural(self):
noun = Noun.proper_noun('Bob')
self.assertEqual(noun.plural(),
Noun('Bobs', '', 'Bob', tags=self.plural_proper))
def _generate_static(self):
return [Noun.proper_noun(el['noun'], el['is_plural']) for el in self._static]
def test_definite_removes_proper_tag(self):
noun = Noun.proper_noun('Xs', plural=True)
self.assertEqual(noun.tags, self.plural_proper)
self.assertEqual(noun.definite(),
Noun('the Xs', '', 'Xs', tags=self.definite_plural))
def test_proper_noun_plural_class_method(self):
test = Noun.proper_noun('the Joneses', plural=True)
self.assertEqual(
test,
Noun('the Joneses', '', 'the Joneses',
Tags([WordTag.PROPER, WordTag.PLURAL])))
