def get_context_data(self, **kwargs):
context = super(MarkupView, self).get_context_data(**kwargs)
markup = self.get_object()
m = TextMarkup()
m.from_json(markup.text)
context['text'] = process_markup(m)
context['poem'] = markup.poem
context['poem'].name = markup.poem.get_name()
context['lines_count'] = markup.poem.count_lines()
context['additional'] = markup.get_automatic_additional()
markups = set()
for markup_instance in markup.poem.markups.all():
markups.add(markup_instance.markup_version)
context['markups'] = list(markups)
return context
def handle(self, *args, **options):
engine = Engine(language="ru")
poems = Poem.objects.all()
begin = int(options.get('from'))
end = int(
options.get('to')) if options.get('to') is not None else len(poems)
poems = Poem.objects.all()[begin:end]
xml_path = str(
options.get('xml')) if options.get('xml') is not None else None
raw_path = str(
options.get('raw')) if options.get('raw') is not None else None
db = options.get('db')
author = options.get("author")
markup_version = MarkupVersion.objects.get_or_create(name=author)[0]
ModelMarkup.objects.filter(markup_version=markup_version).delete()
xml_writer = None
raw_writer = None
if xml_path is not None:
xml_path = os.path.join(BASE_DIR, xml_path)
xml_writer = Writer(FileType.XML, xml_path)
xml_writer.open()
if raw_path is not None:
raw_path = os.path.join(BASE_DIR, raw_path)
raw_writer = Writer(FileType.RAW, raw_path)
raw_writer.open()
i = 0
stress_predictor = engine.get_stress_predictor(
stress_model_path=STRESS_MODEL,
zalyzniak_dict=ZALYZNYAK_DICT,
stress_trie_path=TRIE_PATH,
raw_stress_dict_path=RAW_DICT_PATH)
for p in poems:
if "Automatic" in author:
markup = Markup.process_text(p.text, stress_predictor)
markup, result = MetreClassifier.improve_markup(markup)
if xml_writer is not None:
xml_writer.write_markup(markup)
if raw_writer is not None:
raw_writer.write_markup(markup)
if db:
ModelMarkup.objects.create(poem=p,
text=markup.to_json(),
author="Automatic2",
additional=result.to_json(),
markup_version=markup_version)
else:
markup = p.markups.filter(author=author)[0]
if xml_writer is not None:
xml_writer.write_markup(markup.get_markup())
if raw_writer is not None:
raw_writer.write_markup(markup.get_markup())
i += 1
print(i)
if raw_writer is not None:
raw_writer.close()
if xml_writer is not None:
xml_writer.close()
def get_markup(self, text: str, language: str = "ru") -> Markup:
"""
:param text: текст.
:param language: язык.
:return: его разметка по словарю.
"""
return Markup.process_text(text, self.get_stress_predictor(language))
def test_metre_classifier6(self):
text = "Лючинь печальная читала вечером ручьисто-вкрадчиво,\n" \
"Так чутко чувствуя журчащий вычурно чужой ей плач,\n" \
"И, в человечестве чтя нечто вечное, чем чушь Бокаччио,\n" \
"От чар отчаянья кручинно-скучная, чла час удач."
markup, result = MetreClassifier.improve_markup(Markup.process_text(text, self.stress_predictor))
self.assertTrue(result.metre == "iambos")
def test_metre_classifier2(self):
text = "Буря мглою небо кроет,\n" \
"Вихри снежные крутя;\n" \
"То, как зверь, она завоет,\n" \
"То заплачет, как дитя..."
markup, result = MetreClassifier.improve_markup(Markup.process_text(text, self.stress_predictor))
self.assertEqual(result.metre, "choreios")
def test_metre_classifier5(self):
text = "Глыбу кварца разбили молотом,\n" \
"И, веселым огнем горя,\n" \
"Заблестели крупинки золота\n" \
"В свете тусклого фонаря.\n" \
"И вокруг собрались откатчики:\n" \
"Редкий случай, чтоб так, в руде!\n" \
"И от ламп заплясали зайчики,\n" \
"Отражаясь в черной воде...\n" \
"Прислонившись к мокрой стене,\n" \
"Мы стояли вокруг.\n" \
"Курили,\n" \
"Прислонившись к мокрой стене,\n" \
"И мечтательно говорили\n" \
"Не о золоте — о весне.\n" \
"И о том, что скоро, наверно,\n" \
"На заливе вспотеет лед\n" \
"И, снега огласив сиреной,\n" \
"Наконец придет пароход...\n" \
"Покурили еще немного,\n" \
"Золотинки в кисет смели\n" \
"И опять — по своим дорогам,\n" \
"К вагонеткам своим пошли.\n" \
"Что нам золото? В дни тяжелые\n" \
"Я от жадности злой не слеп.\n" \
"Самородки большие, желтые\n" \
"Отдавал за табак и хлеб.\n" \
"Не о золоте были мысли...\n" \
"В ночь таежную у костра\n" \
"Есть над чем поразмыслить в жизни,\n" \
"Кроме\n" \
"Золота-серебра."
markup, result = MetreClassifier.improve_markup(Markup.process_text(text, self.stress_predictor))
self.assertTrue(result.metre == "dolnik3" or result.metre == "dolnik2")
def test_metre_classifier1(self):
text = "Горит восток зарёю новой.\n" \
"Уж на равнине, по холмам\n" \
"Грохочут пушки. Дым багровый\n" \
"Кругами всходит к небесам."
markup, result = MetreClassifier.improve_markup(Markup.process_text(text, self.stress_predictor))
self.assertIsInstance(markup, Markup)
self.assertIsInstance(result, ClassificationResult)
self.assertEqual(result.metre, "iambos")
def classify_metre(self, text: str, language: str = "ru") -> str:
"""
:param text: текст.
:param language: язык.
:return: его метр.
"""
return MetreClassifier.classify_metre(
Markup.process_text(text,
self.get_stress_predictor(language))).metre
def test_improve(self):
text = "Буря мглою небо кроет,\n" \
"Вихри снежные крутя;\n" \
"То, как зверь, она завоет,\n" \
"То заплачет, как дитя..."
initial_markup = Markup.process_text(text, self.stress_predictor)
markup, result = MetreClassifier.improve_markup(copy.deepcopy(initial_markup))
self.assertNotEqual(markup.lines[0].words[0].syllables[0].stress, -1)
self.assertEqual(markup.lines[0].words[0].syllables[1].stress, -1)
def __markup_text(text: str, stress_predictor: StressPredictor) -> Markup:
"""
Разметка текста.
:param text: текст.
:return: разметка.
"""
markup = Markup.process_text(text, stress_predictor)
markup = MetreClassifier.improve_markup(markup)[0]
return markup
def get_improved_markup(
self,
text: str,
language: str = "ru") -> Tuple[Markup, ClassificationResult]:
"""
:param text: текст.
:param language: язык.
:return: его разметка по словарю, классификатору метру и ML классификатору.
"""
markup = Markup.process_text(text, self.get_stress_predictor(language))
return MetreClassifier.improve_markup(markup)
def test_metre_classifier3(self):
text = "На стеклах нарастает лед,\n"\
"Часы твердят: «Не трусь!»\n"\
"Услышать, что ко мне идет,\n"\
"И мертвой я боюсь.\n"\
"Как идола, молю я дверь;\n"\
"«Не пропускай беду!»\n"\
"Кто воет за стеной, как зверь,\n"\
"Кто прячется в саду?"
markup, result = MetreClassifier.improve_markup(Markup.process_text(text, self.stress_predictor))
self.assertEqual(result.metre, "iambos")
def write_markup(self, markup: Markup) -> None:
"""
Запись разметки в уже открытый файл.
:param markup: разметка.
"""
assert self.file is not None
if self.type == FileType.XML:
xml = markup.to_xml().encode('utf-8')\
.replace(b'<?xml version="1.0" encoding="UTF-8" ?>', b'').decode('utf-8')
self.file.write(xml)
elif self.type == FileType.RAW:
Writer.__write_markup_raw(markup, self.file)
def test_from_to(self):
clean_markup = Markup()
self.assertEqual(MARKUP_EXAMPLE,
clean_markup.from_xml(MARKUP_EXAMPLE.to_xml()))
clean_markup = Markup()
self.assertEqual(MARKUP_EXAMPLE,
clean_markup.from_json(MARKUP_EXAMPLE.to_json()))
def read_vocabulary(path: str):
"""
Считывание словаря.
:param path: путь к словарю.
:return: слово и его индекс.
"""
paths = Reader.get_paths(path, FileType.VOCAB.value)
for filename in paths:
with open(filename, "r", encoding="utf-8") as file:
for line in file:
fields = line.strip().split('\t')
yield Markup().from_raw(fields[0]).lines[0].words[0], int(fields[1])
def read_markups(path: str, source_type: FileType, is_processed: bool,
stress_predictor: StressPredictor=None) -> Iterator[Markup]:
"""
Считывание разметок (включая разметку по сырым текстам).
:param path: путь к файлу/папке.
:param source_type: тип файлов.
:param is_processed: уже размеченные тексты?
:param stress_predictor: классификатор ударений (для неразмеченных текстов).
"""
paths = Reader.get_paths(path, source_type.value)
for filename in paths:
with open(filename, "r", encoding="utf-8") as file:
if is_processed:
if source_type == FileType.XML:
for elem in Reader.__xml_iter(file, 'markup'):
yield Markup().from_xml(etree.tostring(elem, encoding='utf-8', method='xml'))
elif source_type == FileType.JSON:
j = json.load(file)
for item in j['items']:
yield Markup().from_dict(item)
elif source_type == FileType.RAW:
separator_count = 0
text = ""
for line in file:
if line == "\n":
separator_count += 1
else:
text += line
if separator_count == 3:
separator_count = 0
yield Markup().from_raw(text)
if text != "":
yield Markup().from_raw(text)
else:
assert stress_predictor is not None
for text in Reader.read_texts(filename, source_type):
yield Reader.__markup_text(text, stress_predictor)
def test_metre_classifier4(self):
text = "Вот уж вечер. Роса\n" \
"Блестит на крапиве.\n"\
"Я стою у дороги,\n"\
"Прислонившись к иве.\n"\
"От луны свет большой\n"\
"Прямо на нашу крышу.\n"\
"Где-то песнь соловья\n"\
"Хорошо и тепло,\n"\
"Как зимой у печки.\n"\
"И березы стоят,\n"\
"Как большие свечки.\n"\
"И вдали за рекой,\n"\
"Видно, за опушкой,\n"\
"Сонный сторож стучит\n"\
"Мертвой колотушкой."
markup, result = MetreClassifier.improve_markup(Markup.process_text(text, self.stress_predictor))
self.assertTrue(result.metre == "dolnik3" or result.metre == "dolnik2")
def generate_poem_by_line(self, line: str, rhyme_pattern: str,
stress_predictor: StressPredictor) -> str:
"""
Генерация стихотвторения по одной строчке.
:param stress_predictor: классификатор.
:param line: строчка.
:param rhyme_pattern: шаблон рифмы.
:return: стихотворение
"""
markup, result = MetreClassifier.improve_markup(
Markup.process_text(line, stress_predictor))
rhyme_word = markup.lines[0].words[-1]
count_syllables = sum(
[len(word.syllables) for word in markup.lines[0].words])
metre_pattern = CompilationsSingleton.get().get_patterns(
result.metre, count_syllables)[0]
metre_pattern = metre_pattern.lower().replace("s",
"+").replace("u", "-")
letters_to_rhymes = {rhyme_pattern[0]: {rhyme_word}}
generated = self.generate_poem(metre_pattern, rhyme_pattern,
len(metre_pattern), letters_to_rhymes)
poem = line + "\n" + "\n".join(generated.split("\n")[1:])
return poem
from rupo.main.markup import Markup, Line, Word, Syllable
MARKUP_EXAMPLE = Markup("Соломка король себя.\n Пора виться майкой в.", [
Line(0, 20, "Соломка король себя.", [
Word(0, 7, "Соломка",
[Syllable(0, 2, 0, "Со"),
Syllable(2, 5, 1, "лом", 3),
Syllable(5, 7, 2, "ка")]),
Word(8, 14, "король",
[Syllable(0, 2, 0, "ко"),
Syllable(2, 6, 1, "роль", 3)]),
Word(15, 19, "себя",
[Syllable(0, 2, 0, "се"),
Syllable(2, 4, 1, "бя", 3)])]),
Line(21, 43, " Пора виться майкой в.",[
Word(22, 26, "Пора",
[Syllable(0, 2, 0, "По", 1),
Syllable(2, 4, 1, "ра", 3)]),
Word(27, 33, "виться",
[Syllable(0, 2, 0, "ви", 1),
Syllable(2, 6, 1, "ться")]),
Word(34, 40, "майкой",
[Syllable(0, 3, 0, "май", 1),
Syllable(3, 6, 1, "кой")]),
Word(41, 42, "в", [])
])])
def test_process_text(self):
text = "Соломка король себя.\n Пора виться майкой в."
markup = Markup.process_text(text, self.stress_predictor)
self.assertEqual(markup.to_json(), MARKUP_EXAMPLE.to_json())
def get_markup(self):
markup = InternalMarkup()
markup.from_json(self.text)
return markup