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