def compose(self):
"""
俳句を詠む．
"""
first_loop_limit = 500
first_current_loop = 0
while True:
logger.debug('+++ current loop: {} +++'.format(first_current_loop))
first_current_loop += 1
if first_current_loop == first_loop_limit:
return "***** だめでした *****"
try:
root = PhraseTree.define_root(
possible_next_words=self._get_word_list())
first_phrase_tree = self.construct_syllable(root, self.FIVE)
first_text_list = Phrase.text_list
PhraseTree.disclose(first_phrase_tree, "first -------------")
except ValueError:
logger.debug('***** first ValueError *****')
continue
try:
root = PhraseTree.define_root(
possible_next_words=first_phrase_tree.possible_next_words)
second_phrase_tree = self.construct_syllable(root, self.SEVEN)
second_last_vowel = Phrase.last_vowel
second_text_list = Phrase.text_list
PhraseTree.disclose(second_phrase_tree, "second -------------")
except ValueError:
logger.debug('***** second ValueError *****')
continue
try:
root = PhraseTree.define_root(
possible_next_words=second_phrase_tree.possible_next_words)
third_phrase_tree = self.construct_syllable(root, self.FIVE)
third_last_vowel = Phrase.last_vowel
third_text_list = Phrase.text_list
PhraseTree.disclose(third_phrase_tree, "third -------------")
except ValueError:
logger.debug('***** third ValueError *****')
continue
if Rhymer.is_rhymed(second_last_vowel, third_last_vowel):
haiku = "".join(first_text_list + second_text_list +
third_text_list)
logger.debug("[Haiku] >>> {}".format(haiku))
return haiku
def test_get_last_tree(self):
WordsData(self.WORDS)
word_tuple = (
Words(
{
"word": "古池",
"vowel": "ウウイエ",
"length": 4,
"part": "名詞"
}
),
Words(
{
"word": "蛙",
"vowel": "アエウ",
"length": 3,
"part": "名詞"
}
),
Words(
{
"word": "あ",
"vowel": "ア",
"length": 1,
"part": "名詞"
}
)
)
root = PhraseTree.define_root(possible_next_words=list(self.SUCCESS_CHAINS.keys()))
next_tree = PhraseTree(current_words=word_tuple)
root.next_tree = next_tree
self.assertEqual(
root.get_last_tree(root),
next_tree
)
def test_construct_syllable(self):
WordsData.words_data = self.SUCCESS_WORDS_TWELVE
ChainsData.chains_data = self.SUCCESS_CHAINS_TWELVE
haiker = Haiker()
root = PhraseTree.define_root(
possible_next_words=list(self.SUCCESS_CHAINS_TWELVE.keys()))
self.assertIsInstance(haiker.construct_syllable(root, self.TWELVE),
PhraseTree)
pt = haiker.construct_syllable(root, self.TWELVE)
self.assertEqual(PhraseTree.count_phrase_len(pt), self.TWELVE)
def test_construct_syllable_initialize_empty(self):
"""
生成中，単語の候補リストが空担った場合
"""
WordsData.words_data = self.EMPTY_LIST
ChainsData.chains_data = self.EMPTY_DICT
haiker = Haiker()
root = PhraseTree.define_root(
possible_next_words=list(ChainsData.chains_data.keys()))
with self.assertRaises(ValueError):
haiker.construct_syllable(root, self.TWELVE)
def test_construct_syllable_failure(self):
WordsData.words_data = [{
"word": "あ",
"vowel": "ア",
"length": 1,
"part": "名詞"
}, {
"word": "い",
"vowel": "イ",
"length": 1,
"part": "名詞"
}]
ChainsData.chains_data = {"あ": ["い"]}
haiker = Haiker()
root = PhraseTree.define_root(
possible_next_words=list(ChainsData.chains_data.keys()))
with self.assertRaises(ValueError):
haiker.construct_syllable(root, self.TWELVE)
def test_get_text_list_first_and_last(self):
"""
最初のツリー(root の次)に対して
"""
WordsData.words_data = self.SUCCESS_WORDS_TWELVE
root = PhraseTree.define_root(possible_next_words=list(self.SUCCESS_CHAINS_TWELVE.keys()))
word_tuple = (
Words(
{
"word": "ああああ",
"vowel": "アアアア",
"length": 4,
"part": "名詞"
}
),
Words(
{
"word": "いいいい",
"vowel": "イイイイ",
"length": 4,
"part": "名詞"
}
),
Words(
{
"word": "うううう",
"vowel": "ウウウウ",
"length": 4,
"part": "名詞"
}
)
)
next_pt = PhraseTree(current_words=word_tuple,
possible_next_words=list(self.SUCCESS_CHAINS_TWELVE.keys()),
parent=root)
root.next_tree = next_pt
self.assertEqual(
root.get_text_list(next_pt),
['ああああ', 'いいいい', 'うううう']
)
def test_post_proc(self):
"""
Phrase クラスが関連するテストは
Phrase のメンバ変数を初期化してから行う．
"""
WordsData.words_data = self.SUCCESS_WORDS
ChainsData.chains_data = self.SUCCESS_CHAINS
haiker = Haiker()
word_tuple = (Words({
"word": "古池",
"vowel": "ウウイエ",
"length": 4,
"part": "名詞"
}), Words({
"word": "蛙",
"vowel": "アエウ",
"length": 3,
"part": "名詞"
}), Words({
"word": "あ",
"vowel": "ア",
"length": 1,
"part": "名詞"
}))
root = PhraseTree.define_root(
possible_next_words=list(ChainsData.chains_data.keys()))
second_tree = PhraseTree(current_words=word_tuple, parent=root)
root.next_tree = second_tree
# 中間処理
haiker._post_proc(second_tree)
# Phrase 代入済み
self.assertNotEqual(Phrase.text_list, list())
self.assertNotEqual(Phrase.last_words, tuple())
self.assertIsInstance(Phrase.last_vowel, str)
def test_count_phrase_len(self):
WordsData(self.WORDS)
word_tuple = (
Words(
{
"word": "古池",
"vowel": "ウウイエ",
"length": 4,
"part": "名詞"
}
),
Words(
{
"word": "蛙",
"vowel": "アエウ",
"length": 3,
"part": "名詞"
}
),
Words(
{
"word": "あ",
"vowel": "ア",
"length": 1,
"part": "名詞"
}
)
)
root = PhraseTree.define_root(possible_next_words=list(self.SUCCESS_CHAINS.keys()))
second_tree = PhraseTree(current_words=word_tuple,
parent=root)
root.next_tree = second_tree
self.assertEqual(
root.count_phrase_len(second_tree),
8
)
next_word_tuple = (
Words(
{
"word": "蛙",
"vowel": "アエウ",
"length": 3,
"part": "名詞"
}
),
Words(
{
"word": "あ",
"vowel": "ア",
"length": 1,
"part": "名詞"
}
),
Words(
{
"word": "いい",
"vowel": "イイ",
"length": 2,
"part": "名詞"
}
)
)
third_tree = PhraseTree(next_word_tuple,
parent=second_tree)
self.assertEqual(
PhraseTree.count_phrase_len(third_tree),
10
)
def test_get_text_list(self):
WordsData(self.WORDS)
word_tuple = (
Words(
{
"word": "古池",
"vowel": "ウウイエ",
"length": 4,
"part": "名詞"
}
),
Words(
{
"word": "蛙",
"vowel": "アエウ",
"length": 3,
"part": "名詞"
}
),
Words(
{
"word": "あ",
"vowel": "ア",
"length": 1,
"part": "名詞"
}
)
)
root = PhraseTree.define_root(possible_next_words=list(self.SUCCESS_CHAINS.keys()))
second_tree = PhraseTree(current_words=word_tuple,
parent=root)
root.next_tree = second_tree
self.assertEqual(
PhraseTree.get_text_list(second_tree),
['古池', '蛙', 'あ']
)
next_word_tuple = (
Words(
{
"word": "蛙",
"vowel": "アエウ",
"length": 3,
"part": "名詞"
}
),
Words(
{
"word": "あ",
"vowel": "ア",
"length": 1,
"part": "名詞"
}
),
Words(
{
"word": "いい",
"vowel": "イイ",
"length": 2,
"part": "名詞"
}
)
)
third_tree = PhraseTree(current_words=next_word_tuple,
possible_next_words=list(self.SUCCESS_CHAINS.keys()),
parent=second_tree)
second_tree.next_tree = third_tree
self.assertEqual(
PhraseTree.get_text_list(third_tree),
['古池', '蛙', 'あ', 'いい']
)