def test_score_frequency(sample: Sample, sentence: SampleSentence) -> None: """Test `Summarizer` sentence scoring by keyword frequency Arguments: sample {Sample} -- sample data sentence {SampleSentence} -- individual sentence from sample """ summ = Summarizer() words = summ.parser.get_all_stems(sentence.text) top_keywords = summ.get_top_keywords(sample.body) top_keyword_list = pluck_keyword_words(top_keywords) params = ( ( 'density score', sentence.dbs_score, score_by_dbs(words, top_keywords, top_keyword_list), ), ( 'summation score', sentence.sbs_score, score_by_sbs(words, top_keywords, top_keyword_list), ), ) for desc, expected, received in params: result = kinda.eq(received, expected, COMPOSITE_TOLERANCE) assert result, assert_ex(desc, received, expected)
def test_get_sentence(self, sample: Sample, sentence: SampleSentence) -> None: """Test `Summarizer.get_sentence` Arguments: sample {Sample} -- sample data sentence {SampleSentence} -- individual sentence from sample """ summ = Summarizer() title_words = sample.title_words top_keywords = self._get_top_keywords(sample.keywords) top_keyword_list = pluck_keyword_words(top_keywords) text = sentence.text index = sentence.index total = len(sample.sentences) expected = sentence.total_score received = summ.get_sentence(text, index, total, title_words, top_keywords, top_keyword_list).total_score assert kinda.eq(received, expected), assert_ex('sentence score', received, expected, hint='{}: {!r}'.format( sample.name, snip(text)))
def test_score_keyword_frequency(sample: Sample, sentence: SampleSentence): """Test `score_keyword_frequency` in summarizer subpackage Arguments: sample {Sample} -- sample content sentence {SampleSentence} -- sentence from sample """ expected = sentence.keyword_score received = score_keyword_frequency(sentence.dbs_score, sentence.sbs_score) assert kinda.eq(received, expected)
def test_score_total(sample: Sample, sentence: SampleSentence): """Test `score_total` in summarizer subpackage Arguments: sample {Sample} -- sample content sentence {SampleSentence} -- sentence from sample """ expected = sentence.total_score received = score_total(sentence.title_score, sentence.keyword_score, sentence.length_score, sentence.position_score) assert kinda.eq(received, expected)
def test_score_body_sentences(samp: Sample) -> None: """Test `score_body_sentences` for text subpackage Arguments: samp {Sample} -- sample data """ for i, sent in enumerate(score_body_sentences(samp.body, samp.title)): expected = samp.sentences[i].total_score received = sent.total_score assert kinda.eq(received, expected), assert_ex( 'sentence score', received, expected, hint=snip(sent.text))
def test_score_by_length(self, samp: Sample) -> None: """Test `Summarizer.score_by_length` Arguments: samp {Sample} -- sample data """ summ = Summarizer(idiom=samp.idiom) words = summ.parser.get_all_words(samp.sentences[0].text) expected = samp.length_score received = summ.score_by_length(words) assert kinda.eq(received, expected), assert_ex('sentence score', received, expected, hint=' '.join(words))
def test_score_position(index: int, expected: typing.Union[float, Exception]): """Test `score_position` in summarizer subpackage Arguments: index {int} -- index of sentence position (0-based) expected {typing.Union[float, Exception]} -- position score or error """ total = 1000 try: received = score_position(index, total) test = kinda.eq(received, expected) except Exception as err: # pylint: disable=broad-except received = check_exception(err, expected) test = (received == expected) assert test
def test_score_by_title(samp: Sample) -> None: """Test `Parser.score_by_title` Arguments: samp {Sample} -- sample data """ summ = Summarizer(idiom=samp.idiom) title_words = summ.parser.get_key_words(samp.title) sentence_words = summ.parser.get_all_words(samp.sentences[0].text) expected = samp.title_score received = score_by_title(title_words, sentence_words) assert kinda.eq(received, expected), assert_ex( 'title score', received, expected, hint='\n'.join(['', repr(title_words), repr(sentence_words)]))
def compare_score(score_a: float, score_b: float) -> int: """Compare score property of `kw_a` to `kw_b` (unambiguous) Arguments: score_a {float} -- keyword score score_b {float} -- keyword score Returns: int -- `score_a lt score_b`: -1, `score_a eq score_b`: 0, `score_a gt score_b`: 1 """ if kinda.eq(score_a, score_b): return 0 if score_a < score_b: return -1 return 1
def test_get_keywords(self, samp: Sample) -> None: """Test `Parser.get_keywords` Arguments: samp {Sample} -- sample data """ exp_words, exp_scores = self._get_sample_keyword_data(samp) rcv_words, rcv_scores = self._get_keyword_result(samp.body) for word in set(exp_words + rcv_words): assert (word in exp_words) and (word in rcv_words), assert_ex( 'word list mismatch', rcv_words, exp_words) expected = exp_scores[word] received = rcv_scores[word] assert kinda.eq(received, expected), assert_ex( 'bad keyword score', received, expected, hint=word)
def __eq__(self, other) -> bool: return kinda.eq(self.total_score, other.total_score, rel_tol=COMPOSITE_TOLERANCE)