def test_indexed_all_words(self): sentence_one = [BasicWord('hi'), BasicWord('there'), BasicWord('guy')] sentence_two = [BasicWord('ho'), BasicWord('there')] paragraph = Paragraph([Sentence(sentence_one), Sentence(sentence_two)]) all_sentences = [sentence_one, sentence_two] for s_index, w_index, word in paragraph.indexed_all_words(): self.assertEqual(word, all_sentences[s_index][w_index])
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 test_all_words(self): sentence_one = [BasicWord('hi'), BasicWord('there')] sentence_two = [BasicWord('ho'), BasicWord('there')] paragraph = Paragraph([Sentence(sentence_one), Sentence(sentence_two)]) all_words = sentence_one + sentence_two for index, word in enumerate(paragraph.all_words()): self.assertEqual(word, all_words[index])
def test_set_sentence(self): tags = Tags([StatusTag.RAW]) sentences = [Sentence(), Sentence(), Sentence()] new_sentence = Sentence([BasicWord('z')]) paragraph = Paragraph(sentences, tags).set_sentence(1, new_sentence) expected = Paragraph([Sentence(), new_sentence, Sentence()], tags) self.assertEqual(paragraph, expected)
def setUp(self): self.sentence_list = [ Sentence([BasicWord('a'), Verb('b'), BasicWord('c')]), Sentence([BasicWord('d'), Verb('e')]) ] self.tags = Tags([StatusTag.RAW, StatusTag.HAS_PLURALS]) self.paragraph = Paragraph(self.sentence_list, self.tags)
def test_from_word_lists(self): word_lists = [[BasicWord('hi')], [BasicWord('ho')]] tags = Tags([StatusTag.RAW]) paragraph = Paragraph.from_word_lists(word_lists, tags) self.assertEqual(paragraph.sentence_list(), [Sentence(lst) for lst in word_lists]) self.assertEqual(paragraph.tags, tags) paragraph = Paragraph.from_word_lists(word_lists) self.assertEqual(paragraph.sentence_list(), [Sentence(lst) for lst in word_lists]) self.assertEqual(paragraph.tags, Tags())
def test_set(self): sentences = [Sentence([BasicWord('hi'), BasicWord('there')]), Sentence([BasicWord('ho')])] tags = Tags([StatusTag.NOUN_ERRORS]) paragraph = Paragraph(sentences, tags) new_paragraph = paragraph.set(0, 1, BasicWord('new')) self.assertEqual(paragraph.sentence_list(), sentences) self.assertEqual(paragraph.tags, tags) expected = [Sentence([BasicWord('hi'), BasicWord('new')]), Sentence([BasicWord('ho')])] self.assertEqual(new_paragraph.sentence_list(), expected) self.assertEqual(new_paragraph.tags, tags)
def test_create_chain_paragraph_output(self): random.seed(4567) answer = self.rp.create_chain_paragraph(4) sentences = [ Sentence([Noun('water'), Verb('eat'), Noun('rice'), EXCLAMATION]), Sentence([ Noun('rice'), Verb('give'), US, BasicWord.preposition('to'), Noun('cat'), PERIOD ]), Sentence([Noun('cat'), Verb('eat'), Noun('dog'), PERIOD]), Sentence([ Noun('dog'), Verb('jump'), BasicWord.preposition('over'), Noun('sand'), PERIOD ]), ] expected = Paragraph(sentences, self.raw_tags) self.assertEqual(answer, expected)
def test_error_maker_preposition_errors_p_error_gte_one(self): sentences = [ Sentence([ Pronoun.I, Verb('go'), BasicWord.preposition('with'), Pronoun.HIM, Punctuation.PERIOD ]), Sentence([ Pronoun.HE, Verb('run'), BasicWord.preposition('over'), Pronoun.IT, Punctuation.PERIOD ]) ] paragraph = Paragraph(sentences) error_maker = ErrorMaker(paragraph) error_paragraph = error_maker.preposition_errors(1.0).get_paragraph() expected = [ Sentence([ Pronoun.I, BasicWord.preposition('with'), Pronoun.HIM, Verb('go'), Punctuation.PERIOD ]), Sentence([ Pronoun.HE, BasicWord.preposition('over'), Pronoun.IT, Verb('run'), Punctuation.PERIOD ]) ] self.assertEqual(error_paragraph.sentence_list(), expected)
def test_error_maker_is_do_errors_p_error_gte_one(self): random.seed(4758) sentences = [ Sentence([Pronoun.HE, Verb('play').third_person()]), Sentence([Verb('stop')]), Sentence([Pronoun.I, Verb('go').negative()]), Sentence([Pronoun.THEY, Verb('go').past_tense()]), Sentence([Pronoun.HIM, Verb('go').past_tense().negative()]) ] paragraph = Paragraph(sentences) error_maker = ErrorMaker(paragraph) error_paragraph = error_maker.is_do_errors(1.0).get_paragraph() expected = [ Sentence([Pronoun.HE, BeVerb.IS, Verb('play')]), Sentence([BeVerb.BE, Verb('stop')]), Sentence([Pronoun.I, BeVerb.AM_NOT, Verb('go')]), Sentence([Pronoun.THEY, BeVerb.WERE, Verb('go')]), Sentence([Pronoun.HIM, BeVerb.WAS_NOT, Verb('go')]) ] self.assertEqual(error_paragraph.sentence_list(), expected)
def test_error_maker_verb_errors_p_error_middle_value(self): random.seed(4758) sentences = [ Sentence([Verb('play'), Verb('like').third_person()]), Sentence([ Verb('cry').negative(), Verb('dry').negative().third_person() ]), Sentence([ Verb('pry').past_tense(), Verb('fry').negative().past_tense() ]) ] paragraph = Paragraph(sentences) error_maker = ErrorMaker(paragraph) error_paragraph = error_maker.verb_errors(0.5).get_paragraph() expected = [ Sentence([Verb('play'), Verb('like').past_tense()]), Sentence([ Verb('cry').negative(), Verb('dry').negative().third_person() ]), Sentence([Verb('pry'), Verb('fry').negative()]) ] self.assertEqual(error_paragraph.sentence_list(), expected)
def test_error_maker_pronoun_errors_p_error_gte_one(self): sentences = [ Sentence([ Pronoun.I, Pronoun.ME, Pronoun.YOU, Pronoun.HE, Pronoun.HIM, Pronoun.SHE, Pronoun.HER, Pronoun.IT, Pronoun.WE, Pronoun.US, Pronoun.THEY, Pronoun.THEM ]), Sentence([ CapitalPronoun.I, Pronoun.ME, CapitalPronoun.YOU, CapitalPronoun.HE, Pronoun.HIM, CapitalPronoun.SHE, Pronoun.HER, CapitalPronoun.IT, CapitalPronoun.WE, Pronoun.US, CapitalPronoun.THEY, Pronoun.THEM ]) ] expected = [ Sentence([ Pronoun.ME, Pronoun.I, Pronoun.YOU, Pronoun.HIM, Pronoun.HE, Pronoun.HER, Pronoun.SHE, Pronoun.IT, Pronoun.US, Pronoun.WE, Pronoun.THEM, Pronoun.THEY ]), Sentence([ CapitalPronoun.ME, Pronoun.I, CapitalPronoun.YOU, CapitalPronoun.HIM, Pronoun.HE, CapitalPronoun.HER, Pronoun.SHE, CapitalPronoun.IT, CapitalPronoun.US, Pronoun.WE, CapitalPronoun.THEM, Pronoun.THEY ]) ] paragraph = Paragraph(sentences) error_maker = ErrorMaker(paragraph) error_paragraph = error_maker.pronoun_errors(1.0).get_paragraph() self.assertEqual(error_paragraph.sentence_list(), expected) error_paragraph = error_maker.pronoun_errors(1.1).get_paragraph() self.assertEqual(error_paragraph.sentence_list(), expected)
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_error_maker_order_of_errors_preposition_errors_affect_is_do_errors( self): sentences = [ Sentence([ CapitalPronoun.I, Verb('play'), Punctuation.PERIOD, BasicWord.preposition('with'), Pronoun.HIM ]), Sentence([ Noun('dog').definite(), Verb('play').third_person(), Punctuation.PERIOD, BasicWord.preposition('with'), Pronoun.HIM ]), ] error_maker = ErrorMaker(Paragraph(sentences)) is_do_preposition = error_maker.is_do_errors(1.0).preposition_errors( 1.0).get_paragraph() expected_str = 'I with him am play. the dog with him is play.' self.assertEqual(str(is_do_preposition), expected_str) preposition_is_do = error_maker.preposition_errors(1.0).is_do_errors( 1.0).get_paragraph() expected_str = 'I with him is play. the dog with him is play.' self.assertEqual(str(preposition_is_do), expected_str)
def test_error_maker_punctuation_errors_p_error_middle_value(self): random.seed(5812) sentences = [ Sentence([CapitalPronoun.I, Verb('go'), Punctuation.PERIOD]), Sentence([CapitalPronoun.HE, Verb('run'), Punctuation.EXCLAMATION]), Sentence([Noun('dog').definite().capitalize(), Punctuation.PERIOD]), Sentence([BasicWord('A'), Punctuation.PERIOD]) ] paragraph = Paragraph(sentences) error_maker = ErrorMaker(paragraph) error_paragraph = error_maker.punctuation_errors(0.5).get_paragraph() expected = [ Sentence([CapitalPronoun.I, Verb('go'), Punctuation.PERIOD]), Sentence([CapitalPronoun.HE, Verb('run'), Punctuation.COMMA]), Sentence([Noun('dog').definite(), Punctuation.COMMA]), Sentence([BasicWord('a'), Punctuation.PERIOD]) ] self.assertEqual(error_paragraph.sentence_list(), expected)
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_create_pool_paragraph_output(self): random.seed(3) paragraph = self.rp.create_pool_paragraph(2, 5) sentences = [ Sentence([Noun('pig'), Verb('eat'), Noun('sand'), PERIOD]), Sentence( [Noun('pig'), Verb('give'), Noun('milk'), Noun('cat'), PERIOD]), Sentence([ Noun('pig'), Verb('jump'), BasicWord.preposition('over'), Noun('water'), PERIOD ]), Sentence([Noun('sand'), Verb('eat'), IT, PERIOD]), Sentence([ Noun('sand'), Verb('give'), Noun('water'), BasicWord.preposition('to'), Noun('milk'), EXCLAMATION ]) ] expected = Paragraph(sentences, self.raw_tags) self.assertEqual(paragraph, expected)
def _to_paragraph(cls, python_dict): sentence_list = [ cls._to_sentence(sentence) for sentence in python_dict['sentence_list'] ] tags = cls._to_status_tags(python_dict['tags']) return Paragraph(sentence_list, tags)
def test_find(self): paragraph = Paragraph.from_word_lists([ [BasicWord('x'), BasicWord('y')], [BasicWord('z'), BasicWord('y'), BasicWord('x')], [BasicWord('q')] ]) self.assertEqual(paragraph.find(BasicWord('x')), [(0, 0), (1, 2)])
def test_init(self): answer_paragraph = Paragraph([Sentence([BasicWord('a')])]) submission_str = 'b' comparitor = ParagraphComparison(answer_paragraph, submission_str) self.assertEqual(comparitor.answer, answer_paragraph) self.assertEqual(comparitor.submission, 'b')
def create_pool_paragraph(self, pool_size: int, num_sentences: int) -> Paragraph: subjects = self.get_subject_pool(pool_size) sentences = [] for _ in range(num_sentences): subj = random.choice(subjects) sentences.append(self._word_maker.sentence(subj, self._p_pronoun)) return Paragraph(sentences, self._raw_tag)
def get_countable_nouns(paragraph: Paragraph) -> List[Noun]: out = [] # Sets are untestable with random.seed for word in paragraph.all_words(): # type: Noun if is_countable_noun(word): base_word = word.to_basic_noun() if base_word not in out: out.append(base_word) return out
def test_create_answer_paragraph_makes_grammatically_correct_paragraph_if_base_paragraph_word_order_is_ok(self): base_sentences = [Sentence([Pronoun.HE, Verb('like'), Noun('dog'), Punctuation.PERIOD]), Sentence([Noun('dog'), Verb('go'), BasicWord.preposition('to'), Noun('house'), Punctuation.PERIOD])] base_paragraph = Paragraph(base_sentences) answer = create_answer_paragraph('', base_paragraph) with_plurals = PluralsAssignment(base_paragraph).assign_plural([]) grammatical = Grammarizer(with_plurals).grammarize_to_present_tense() self.assertEqual(answer, grammatical)
def test_create_answer_paragraph_makes_paragraph_according_to_plurals_in_paragraph_str(self): base_sentences = [Sentence([Noun('dog'), Verb('like'), Noun('cat'), Punctuation.PERIOD])] base_paragraph = Paragraph(base_sentences) paragaph_str = 'A dog like cats,' answer = create_answer_paragraph(paragaph_str, base_paragraph) with_plurals = PluralsAssignment(base_paragraph).assign_plural([Noun('cat')]) expected = Grammarizer(with_plurals).grammarize_to_present_tense() self.assertEqual(answer, expected)
def test_iteration(self): sentence_list = [Sentence([BasicWord('hi')]), Sentence([BasicWord('ho')])] tags = Tags([StatusTag.RAW]) paragraph = Paragraph(sentence_list, tags) for index, sentence in enumerate(paragraph): self.assertEqual(sentence, sentence_list[index]) self.assertTrue(sentence_list[0] in paragraph) self.assertFalse(Sentence([BasicWord('hope')]) in paragraph)
def test_create_answer_paragraph_picks_plural_when_plural_and_singular_present(self): base_sentences = [Sentence([Noun('dog'), Verb('like'), Noun('dog'), Punctuation.PERIOD])] base_paragraph = Paragraph(base_sentences) with_plurals = PluralsAssignment(base_paragraph).assign_plural([Noun('dog')]) expected = Grammarizer(with_plurals).grammarize_to_present_tense() for paragraph_Str in ('dogs like a dog.', 'a dog like dogs.'): answer = create_answer_paragraph(paragraph_Str, base_paragraph) self.assertEqual(answer, expected)
def test_create_answer_paragraph_can_pick_plural_when_paragraph_str_has_capital_letters(self): base_sentences = [Sentence([Noun('dog'), Verb('like'), Noun('cat'), Punctuation.PERIOD])] base_paragraph = Paragraph(base_sentences) paragaph_str = 'DOGS like CATS' answer = create_answer_paragraph(paragaph_str, base_paragraph) with_plurals = PluralsAssignment(base_paragraph).assign_plural([Noun('dog'), Noun('cat')]) expected = Grammarizer(with_plurals).grammarize_to_present_tense() self.assertEqual(answer, expected)
def test_create_answer_paragraph_is_in_past_tense_if_has_tag_simple_past(self): base_sentences = [Sentence([Noun('dog'), Verb('like'), Noun('cat'), Punctuation.PERIOD])] base_paragraph = Paragraph(base_sentences, Tags([StatusTag.SIMPLE_PAST])) paragaph_str = 'A dog liked cats,' answer = create_answer_paragraph(paragaph_str, base_paragraph) with_plurals = PluralsAssignment(base_paragraph).assign_plural([Noun('cat')]) expected = Grammarizer(with_plurals).grammarize_to_past_tense() self.assertEqual(answer, expected)
def test_to_obj_with_tagged_BasicWord_in_sentence(self): paragraph = Paragraph([ Sentence([ BasicWord('x', Tags([tag for tag in WordTag])), BasicWord('y') ]) ]) as_dict = Serializer.to_dict(paragraph) self.assertEqual(Serializer.to_obj(as_dict), paragraph)
def test_compare_by_sentence_paragraph_str_eq_submission_str(self): answer_paragraph = Paragraph([Sentence([BasicWord('a')])]) submission_str = str(answer_paragraph) comparitor = ParagraphComparison(answer_paragraph, submission_str) comparison = comparitor.compare_by_sentences() expected = { 'error_count': 0, 'hint_paragraph': submission_str, 'missing_sentences': 0 } self.assertEqual(comparison, expected)