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)
