def get_replays_in_socket_unique(_, socket_group_list) -> list:
"""
Создать документ Повторы в пределах гнезда.txt .
Удалить из него строки с ЗС групп, с ЗС подгрупп.
Найти среди оставшихся строк уникальные строки.
Расположить их в соответствии с алфавитным порядком слов.
"""
# Повторы в пределах гнезда.txt
replays_in_socket = get_replays_in_socket(_, socket_group_list)
save_list_to_file(replays_in_socket,
'Повторы в пределах гнезда.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в пределах гнезда.txt')
print(f'... сортировка ...')
flag = False
out_list = [
x for x in replays_in_socket
if ((flag, flag := x)[0] and x and not x.startswith('!'))
]
socket_unique = [x for x, count in Counter(out_list).items() if count == 1]
word_forms = sorted(list(set(socket_unique)),
key=lambda x: x.replace('*', '').lower().strip())
return word_forms
def get_words_with_exp_notes_no_homonyms(word_forms_bases, _) -> list:
"""
Создать документы Слова с пояснительными примечаниями БС.txt
и Омонимы БС (ЗС групп и одиночки).txt .
Найти в документе Слова с пояснительными примечаниями БС.txt строки,
отсутствующие в документе Омонимы БС (ЗС групп и одиночки).txt .
"""
# Слова с пояснительными примечаниями БС
words_with_exp_notes = get_words_with_exp_notes(word_forms_bases, _)
save_list_to_file(words_with_exp_notes,
'Слова с пояснительными примечаниями БС.txt',
encoding='cp1251')
print(f'Создан документ: Слова с пояснительными примечаниями БС.txt')
print(f'... сортировка ...')
# Омонимы БС (ЗС групп и одиночки)
homonyms = get_homonyms(word_forms_bases, _)
save_list_to_file(homonyms, 'Омонимы БС (ЗС групп и одиночки).txt',
encoding='cp1251')
print(f'Создан документ: Омонимы БС (ЗС групп и одиночки).txt')
print(f'... сортировка ...')
word_forms = [x for x in words_with_exp_notes if x not in homonyms]
return word_forms
def get_replays_in_socket_strings(_, socket_group_list) -> list:
"""
Создать документ Повторы в пределах гнезда.txt .
Удалить из него строки с ЗС групп, с ЗС подгрупп
и с многокорневыми словами.
Удалить повторы строк.
Расположить оставшиеся строки в соответствии с алфавитным порядком слов.
"""
# Повторы в пределах гнезда.txt
replays_in_socket = get_replays_in_socket(_, socket_group_list)
save_list_to_file(replays_in_socket,
'Повторы в пределах гнезда.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в пределах гнезда.txt')
print(f'... сортировка ...')
flag = False
out_list = [
x for x in replays_in_socket
if ((flag, flag := x)[0] and x and not x.startswith('!')
and not get_socket_word_form(x).root_index)
]
word_forms = sorted(list(set(out_list)),
key=lambda x: x.replace('*', '').lower().strip())
return word_forms
def get_nouns_ch_both_parts_identifiers(word_forms_bases, _) -> list:
"""
1. Создать документ Сущ-ные с дефисом. Изм. обе части.txt .
2. Найти в БС группы с ЗС из документа
Сущ-ные с дефисом. Изм. обе части.txt .
3. Создать документ Сущ-ные с дефисом. Изм. обе части. Идентификаторы.txt
и вставить в него все идентификаторы из найденных согласно п. 2 групп.
4. Удалить повторы одинаковых идентификаторов, оставив только уникальные.
5. Упорядочить идентификаторы следующим образом:
сначала с учётом числа (сначала идентификаторы единственного числа,
затем - множественного);
затем учитывая порядок падежей: И Р Д В Т П ;
затем - в соответствии с алфавитным порядком
остальных элементов идентификаторов.
6. Сохранить документ
Сущ-ные с дефисом. Изм. обе части. Идентификаторы.txt .
"""
# Сущ-ные с дефисом. Изм. обе части.txt
nouns_ch_both_parts = get_nouns_hyphenated_ch_both_parts(
word_forms_bases, _)
save_list_to_file(nouns_ch_both_parts,
'Сущ-ные с дефисом. Изм. обе части.txt',
encoding='cp1251')
print(f'Создан документ: Сущ-ные с дефисом. Изм. обе части.txt')
print(f'... сортировка ...')
se_idf = set() # .Се
semn_idf = set() # .Смн
se_spec_idf = set() # .Се_Смн
semn_spec_idf = set() # .Смн_Се
identifiers = []
for group in word_forms_bases:
if str(group.title_word_form) in nouns_ch_both_parts:
forms = [group.title_word_form] + group.word_forms
idfs = [x.idf for x in forms]
for identifier in idfs:
if identifier.count('е') > 1:
se_idf.add(identifier)
elif identifier.count('мн') > 1:
semn_idf.add(identifier)
elif identifier[2] == 'е':
se_spec_idf.add(identifier)
else:
semn_spec_idf.add(identifier)
identifiers += sorted(list(se_idf),
key=lambda x: (sorting_by_case[x[3]], x))
identifiers += sorted(list(semn_idf),
key=lambda x: (sorting_by_case[x[4]], x))
identifiers += sorted(list(se_spec_idf),
key=lambda x: (sorting_by_case[x[3]], x))
identifiers += sorted(list(semn_spec_idf),
key=lambda x: (sorting_by_case[x[4]], x))
return identifiers
def get_pronouns_hyphenated_identifiers(word_forms_bases, _) -> list:
"""
1. Создать документ Мест-ния с дефисом. Изм. обе части.txt .
2. Найти в БС группы с ЗС из документа
Мест-ния с дефисом. Изм. обе части.txt .
3. Создать документ Мест-ния с дефисом. Изм. обе части. Идентификаторы.txt
и вставить в него все идентификаторы из найденных согласно п. 2 групп.
4. Удалить повторы одинаковых идентификаторов, оставив только уникальные.
5. Упорядочить идентификаторы следующим образом:
сначала с учётом числа (сначала идентификаторы единственного числа,
затем - множественного);
затем учитывая порядок падежей: И Р Д В Т П ;
затем - в соответствии с алфавитным порядком
остальных элементов идентификаторов.
6. Сохранить документ
Мест-ния с дефисом. Изм. обе части. Идентификаторы.txt .
"""
# Мест-ния с дефисом. Изм. обе части.txt
pronouns_hyphenated_ch_both_parts = get_pronouns_hyphenated_ch_both_parts(
word_forms_bases, _)
save_list_to_file(pronouns_hyphenated_ch_both_parts,
'Мест-ния с дефисом. Изм. обе части.txt',
encoding='cp1251')
print(f'Создан документ: Мест-ния с дефисом. Изм. обе части.txt')
print(f'... сортировка ...')
m_idf = set() # .М
m_gen_idf = set() # .М(м)(ж)(с)
m_mn_idf = set() # .Ммн
identifiers = []
for group in word_forms_bases:
if (str(group.title_word_form) in pronouns_hyphenated_ch_both_parts
and group.title_word_form.idf.startswith('.М')):
forms = [group.title_word_form] + group.word_forms
idfs = [x.idf for x in forms]
for identifier in idfs:
if identifier[2:4] == 'мн':
m_mn_idf.add(identifier)
elif identifier[2] in ('м', 'ж', 'с'):
m_gen_idf.add(identifier)
else:
m_idf.add(identifier)
identifiers += sorted(list(m_idf),
key=lambda x: (sorting_by_case[x[2]], x))
identifiers += sorted(list(m_gen_idf),
key=lambda x:
(sorting_by_gender[x[2]], sorting_by_case[x[3]], x))
identifiers += sorted(list(m_mn_idf),
key=lambda x: (sorting_by_case[x[4]], x))
return identifiers
def get_common_words_bs(word_forms_bases, socket_group_list) -> list:
"""
Создать документ Снимок БС.txt .
Удалить из него строки из документов:
Многокорневые слова БС.txt ;
Повторы в пределах гнезда. 1 раз в БС.txt ;
Омонимы БС (ЗС групп и одиночки).txt .
Сохранить получившийся документ и переименовать его в Обычные слова БС.txt .
Примечание. В 3 указанных документах могут быть одинаковые строки.
"""
# Снимок БС.txt
bs_snapshot = get_bs_snapshot(word_forms_bases, socket_group_list)
save_list_to_file(
bs_snapshot, 'Снимок БС.txt', encoding='cp1251')
print(f'Создан документ: Снимок БС.txt')
print(f'... сортировка ...')
# Многокорневые слова БС.txt
multi_root_words = get_multi_root_words(
word_forms_bases, socket_group_list)
save_list_to_file(
multi_root_words, 'Многокорневые слова БС.txt', encoding='cp1251')
print(f'Создан документ: Многокорневые слова БС.txt')
print(f'... сортировка ...')
# Повторы в пределах гнезда. 1 раз в БС.txt
repeats_w_socket_1_in_bs = get_repeats_w_socket_1_in_bs(
word_forms_bases, socket_group_list)
save_list_to_file(
repeats_w_socket_1_in_bs, 'Повторы в пределах гнезда. 1 раз в БС.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в пределах гнезда. 1 раз в БС.txt')
print(f'... сортировка ...')
# Омонимы БС (ЗС групп и одиночки).txt
homonyms = get_homonyms(word_forms_bases, socket_group_list)
save_list_to_file(
homonyms, 'Омонимы БС (ЗС групп и одиночки).txt', encoding='cp1251')
print(f'Создан документ: Омонимы БС (ЗС групп и одиночки).txt')
print(f'... сортировка ...')
not_ordinary = multi_root_words + repeats_w_socket_1_in_bs + homonyms
word_forms = list(sorted(
list(set(bs_snapshot) - set(not_ordinary)),
key=lambda x: x.replace('*', '').lower().strip()
))
return word_forms
def get_unknown_etymology(_, socket_group_list) -> list:
"""
Создать документ Слова с этимологическими примечаниями.txt
и найти в нём строки, оканчивающиеся комбинацией символов *?
"""
# Слова с этимологическими примечаниями.txt
socket_with_etml_notes = get_socket_with_etml_notes(_, socket_group_list)
save_list_to_file(socket_with_etml_notes,
'Слова с этимологическими примечаниями.txt',
encoding='cp1251')
print(f'Создан документ: Слова с этимологическими примечаниями.txt')
print(f'... сортировка ...')
word_forms = [x for x in socket_with_etml_notes if x.endswith('*?')]
return word_forms
def get_under_the_influence(_, socket_group_list) -> list:
"""
Создать документ Слова с этимологическими примечаниями.txt
и найти в нём строки, в которых имеется комбинация символов ++
"""
# Слова с этимологическими примечаниями.txt
socket_with_etml_notes = get_socket_with_etml_notes(_, socket_group_list)
save_list_to_file(socket_with_etml_notes,
'Слова с этимологическими примечаниями.txt',
encoding='cp1251')
print(f'Создан документ: Слова с этимологическими примечаниями.txt')
print(f'... сортировка ...')
word_forms = [x for x in socket_with_etml_notes if x.find('++') != -1]
return word_forms
def get_formed_from(_, socket_group_list) -> list:
"""
Создать документ Слова с этимологическими примечаниями.txt
и найти в нём строки, в которых имеется символ * ,
после которого через пробел указана комбинация символов <= (* <=)
"""
# Слова с этимологическими примечаниями.txt
socket_with_etml_notes = get_socket_with_etml_notes(_, socket_group_list)
save_list_to_file(socket_with_etml_notes,
'Слова с этимологическими примечаниями.txt',
encoding='cp1251')
print(f'Создан документ: Слова с этимологическими примечаниями.txt')
print(f'... сортировка ...')
word_forms = [x for x in socket_with_etml_notes if x.find('* <=') != -1]
return word_forms
def get_hyphenated_nouns_different_kind(word_forms_bases, _) -> list:
"""Создать документ Сущ-ные с дефисом. Изм. обе части.txt .
Найти в созданном документе строки, в которых в спец. информации
имеются следующие комбинации указателей рода:
а. указатель муж. рода м и указатель жен. рода
с предшествующим дефисом -ж (м…-ж…) [в том числе м!…-ж!…]
или
б. указатель муж. рода м и указатель ср. рода
с предшествующим дефисом -с (м…-с…) [в том числе м!…-с!…]
или
в. указатель жен. рода ж и указатель муж. рода
с предшествующим дефисом -м (ж…-м…) [в том числе ж!…-м!…]
или
г. указатель жен. рода ж и указатель ср. рода
с предшествующим дефисом -с (ж…-с…) [в том числе ж!…-с!…]
или
д. указатель ср. рода с и указатель муж. рода
с предшествующим дефисом -м (с…-м…) [в том числе с!…-м!…]
или
е. указатель ср. рода с и указатель жен. рода
с предшествующим дефисом -ж (с…-ж…) [в том числе с!…-ж!…]."""
# Сущ-ные с дефисом. Изм. обе части.txt
nouns_ch_both_parts = get_nouns_hyphenated_ch_both_parts(
word_forms_bases, _)
save_list_to_file(nouns_ch_both_parts,
'Сущ-ные с дефисом. Изм. обе части.txt',
encoding='cp1251')
print(f'Создан документ: Сущ-ные с дефисом. Изм. обе части.txt')
print(f'... сортировка ...')
word_forms = []
for title_form in nouns_ch_both_parts:
word_form = get_bs_title_word_form(title_form)
indicator = word_form.info[1]
if not indicator.startswith('мн'):
gender_0, gender_1 = indicator.split('-')
if gender_0[0] != gender_1[0]:
word_forms.append(title_form)
return word_forms
def get_replays_in_socket_duplicate(_, socket_group_list) -> list:
"""
Создать документ Повторы в пределах гнезда.txt .
Удалить из него строки с ЗС групп, с ЗС подгрупп
и с многокорневыми словами.
Найти среди оставшихся строк одинаковые строки.
Создать документ Повторы в гнезде. Повторяющиеся строки.txt ,
вставить в него найденные одинаковые строки
с соблюдением алфавитного порядка слов.
Удалить повторы строк.
Сохранить документ Повторы в гнезде. Повторяющиеся строки.txt .
"""
# Повторы в пределах гнезда.txt
replays_in_socket = get_replays_in_socket(_, socket_group_list)
save_list_to_file(replays_in_socket,
'Повторы в пределах гнезда.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в пределах гнезда.txt')
print(f'... сортировка ...')
flag = False
out_list = [
x for x in replays_in_socket
if ((flag, flag := x)[0] and x and not x.startswith('!')
and not get_socket_word_form(x).root_index)
]
socket_duplicate = [
x for x, count in Counter(out_list).items() if count > 1
]
word_forms = sorted(list(set(socket_duplicate)),
key=lambda x: x.replace('*', '').lower().strip())
return word_forms
def get_repeats_w_socket_1_in_bs(word_forms_bases, socket_group_list) -> list:
"""
Создать документы Повторы в гнезде. Повторяющиеся строки.txt
Найти в БС строки, соответствующие строкам из документа
Повторы в гнезде. Повторяющиеся строки.txt .
Убедиться, что найденные строки отсутствуют в документе
Омонимы БС (ЗС групп и одиночки).txt .
Создать документ Повторы в пределах гнезда. 1 раз в БС.txt
и вставить в него найденные строки.
"""
# Повторы в гнезде. Повторяющиеся строки.txt
socket_duplicate = get_replays_in_socket_duplicate(
word_forms_bases, socket_group_list)
save_list_to_file(
socket_duplicate, 'Повторы в гнезде. Повторяющиеся строки.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в гнезде. Повторяющиеся строки.txt')
print(f'... сортировка ...')
socket_word_forms = [get_socket_word_form(x) for x in socket_duplicate]
socket_str_forms = [x.conformity_form for x in socket_word_forms]
# Омонимы БС (ЗС групп и одиночки).txt
# homonyms = get_homonyms(word_forms_bases, socket_group_list)
#
# save_list_to_file(
# homonyms, 'Омонимы БС (ЗС групп и одиночки).txt', encoding='cp1251')
#
# print(f'Создан документ: Омонимы БС (ЗС групп и одиночки).txt')
# print(f'... сортировка ...')
#
# homonyms_word_forms = [get_bs_title_word_form(x) for x in homonyms]
# homonyms_str_forms = [x.conformity_form for x in homonyms_word_forms]
# Повторы в пределах гнезда. 1 раз в БС.txt
word_forms = []
for group in word_forms_bases:
title_form = group.title_word_form
title_conformity_form = title_form.conformity_form
if title_conformity_form in socket_str_forms:
# if title_conformity_form in homonyms_str_forms:
# print(
# 'В документе Омонимы БС (ЗС групп и одиночки).txt\n'
# f"обнаружена строка: '{title_conformity_form}'"
# )
# print('Для выхода нажмите Enter')
# input()
# sys.exit()
# else:
# word_forms.append(str(title_form))
word_forms.append(str(title_form))
return word_forms
def save_nouns_pattern_combinations(word_forms_bases, _):
"""Создать документы:
Сущ-ные с дефисом. Изм. первая часть.txt ,
Сущ-ные с дефисом. Изм. обе части.txt ,
Сущ-ные с дефисом. Разное число.txt .
Найти в БС строки с ЗС групп, идентификатор которых содержит .С ,
и ЗС отсутствует в документах
Сущ-ные с дефисом. Изм. первая часть.txt ,
Сущ-ные с дефисом. Изм. обе части.txt ,
Сущ-ные с дефисом. Разное число.txt .
Выбрать из найденных строк строки с уникальным сочетанием
элементов спец. информации
(подробнее об элементах спец. информации - см. док-т Структура строки.xlsx,
вкладка Структура спец. информации).
Примечание. При наличии нескольких строк с одинаковым сочетанием
элементов спец. информации выбирать первую (верхнюю) строку,
т.е. строку, слово в которой идёт первым по алфавиту.
Создать документ Существительные. Сочетания шаблонов.csv .
Вставить в 8 столбцов этого документа выбранные строки
(слово - в первый столбец, элементы спец. информации - в другие,
соответствующие им по типу 7 столбцов),
располагая строки в соответствии с алфавитным порядком
элементов спец. информации."""
# Сущ-ные с дефисом. Изм. первая часть.txt
nouns_ch_first_part = get_nouns_hyphenated_ch_first_part(
word_forms_bases, _)
save_list_to_file(nouns_ch_first_part,
'Сущ-ные с дефисом. Изм. первая часть.txt',
encoding='cp1251')
print(f'Создан документ: Сущ-ные с дефисом. Изм. первая часть.txt')
print(f'... сортировка ...')
# Сущ-ные с дефисом. Изм. обе части.txt
nouns_ch_both_parts = get_nouns_hyphenated_ch_both_parts(
word_forms_bases, _)
save_list_to_file(nouns_ch_both_parts,
'Сущ-ные с дефисом. Изм. обе части.txt',
encoding='cp1251')
print(f'Создан документ: Сущ-ные с дефисом. Изм. обе части.txt')
print(f'... сортировка ...')
# Сущ-ные с дефисом. Разное число.txt
nouns_singular_and_plural = get_nouns_hyphenated_singular_and_plural(
word_forms_bases, _)
save_list_to_file(nouns_singular_and_plural,
'Сущ-ные с дефисом. Разное число.txt',
encoding='cp1251')
print(f'Создан документ: Сущ-ные с дефисом. Разное число.txt')
print(f'... сортировка ...')
unusual_words = (nouns_ch_first_part + nouns_ch_both_parts +
nouns_singular_and_plural)
word_forms = []
unique_elements = []
for group in word_forms_bases:
if (group.title_word_form.idf.startswith('.С')
and str(group.title_word_form) not in unusual_words):
elements = ' '.join(group.title_word_form.info)
if elements not in unique_elements:
unique_elements.append(elements)
word_forms.append(group.title_word_form)
in_form_of_list_1 = []
in_form_of_list_2 = []
in_form_of_list_3 = []
for form in word_forms:
indicators = OrderedDict({
'name': form.name,
# 'idf': form.idf,
'animality': '',
'род': '',
'только ед. ч.': '',
'шаблон ед. ч.': '',
'мн': '',
'только мн. ч.': '',
'шаблон мн. ч.': '',
})
for indicator in form.info:
if indicator in ('одуш', 'неод'):
indicators['animality'] = indicator
elif indicator.startswith('мн!'):
indicators['мн'] = 'мн'
indicators['только мн. ч.'] = '!'
indicators['шаблон мн. ч.'] = indicator[3:]
elif indicator.startswith('мн'):
indicators['мн'] = 'мн'
indicators['шаблон мн. ч.'] = indicator[2:]
elif indicator.startswith(('м!', 'ж!', 'с!')):
indicators['род'] = indicator[0]
indicators['только ед. ч.'] = '!'
indicators['шаблон ед. ч.'] = indicator[2:]
elif indicator.startswith(('м', 'ж', 'с')):
indicators['род'] = indicator[0]
indicators['шаблон ед. ч.'] = indicator[1:]
if indicators['только ед. ч.']:
in_form_of_list_2.append(list(indicators.values()))
elif indicators['только мн. ч.']:
in_form_of_list_3.append(list(indicators.values()))
else:
in_form_of_list_1.append(list(indicators.values()))
in_form_of_list_1 = sorted(in_form_of_list_1,
key=lambda x: (x[4], x[7], x[1], x[2]))
in_form_of_list_2 = sorted(in_form_of_list_2,
key=lambda x: (x[4], x[1], x[2]))
in_form_of_list_3 = sorted(in_form_of_list_3,
key=lambda x: (x[7], x[1], x[2]))
in_form_of_list = zip_longest(in_form_of_list_1,
in_form_of_list_2,
in_form_of_list_3,
fillvalue=[''] * 8)
in_form_of_list = [[x for y in lst for x in y] for lst in in_form_of_list]
print(f'\n{reminder_nouns}\n')
save_list_of_lists_to_csv_file(in_form_of_list,
'Существительные. Сочетания шаблонов.csv',
encoding='cp1251',
delimiter=';')
def main():
definitions = 'lists.txt'
print('Настройки:')
print(f'{definitions}\n')
in_bs, in_bg, *out_tasks = [
x for x in list(
get_string_list_from_file(definitions, encoding='cp1251')) if x
]
print(f'БС файл: {in_bs}')
print(f'БГ файл: {in_bg}')
print()
print('Создать списки:')
for task in out_tasks:
print(task)
print()
print(f'... чтение {in_bs} ...')
word_forms_bases = list(read_src_bs(in_bs))
print(f'... чтение {in_bg} ...')
socket_group_list = list(read_src_socket_bs(in_bg))
print()
# Выполнение задач
for task in out_tasks:
print(f'{"* " * 38}*\n')
print(f'Список: {task}\n')
if task.endswith('.txt'):
print(f'... сортировка ...')
out_task = get_filtered_list(word_forms_bases, socket_group_list,
task)
if out_task:
task = task.replace('*', '^')
task = task.replace('/', '[')
task = task.replace('|', ']')
save_list_to_file(out_task, task, encoding='cp1251')
print(f'Создан документ: {task}\n')
print('Для продолжения нажмите Enter')
input()
else:
print(TASK_IS_NOT_DEFINED)
input()
sys.exit()
elif task.endswith('.csv'):
print(f'... сортировка ...')
out_task = run_csv_task(word_forms_bases, socket_group_list, task)
if out_task:
print(f'Создан документ: {task}\n')
print('Для продолжения нажмите Enter')
input()
else:
print(TASK_IS_NOT_DEFINED)
input()
sys.exit()
else:
print(TASK_IS_NOT_DEFINED)
input()
sys.exit()
# End task
print(f'{"* " * 38}*\n')
print(f'Результатаы сохранены в текущей директории:')
print(Path().resolve())
print()
print('Для выхода нажмите Enter')
input()
def save_adjectives_pattern_combinations(word_forms_bases, _):
"""Создать документы:
Прил-ные с дефисом. Изм. первая часть.txt
и Прил-ные с дефисом. Изм. обе части.txt .
Найти в БС строки с ЗС групп, идентификатор которых содержит .П ,
и ЗС отсутствует в документах
Прил-ные с дефисом. Изм. первая часть.txt
и Прил-ные с дефисом. Изм. обе части.txt .
Выбрать из найденных строк строки с уникальным сочетанием
элементов спец. информации
(подробнее об элементах спец. информации - см. док-т Структура строки.xlsx,
вкладка Структура спец. информации).
Примечание. При наличии нескольких строк с одинаковым
сочетанием элементов спец. информации выбирать первую (верхнюю) строку,
т.е. строку, слово в которой идёт первым по алфавиту.
Создать документ Прилагательные. Сочетания шаблонов.csv .
Вставить в 7 столбцов этого документа выбранные строки
(слово - в первый столбец, элементы спец. информации - в другие,
соответствующие им по типу 6 столбцов),
располагая строки в соответствии с алфавитным порядком
элементов спец. информации."""
# Прил-ные с дефисом. Изм. первая часть.txt
adjectives_ch_first_part = get_adjectives_hyphenated_ch_first_part(
word_forms_bases, _)
save_list_to_file(adjectives_ch_first_part,
'Прил-ные с дефисом. Изм. первая часть.txt',
encoding='cp1251')
print(f'Создан документ: Прил-ные с дефисом. Изм. первая часть.txt')
print(f'... сортировка ...')
# Прил-ные с дефисом. Изм. обе части.txt
adjectives_ch_both_parts = get_adjectives_hyphenated_ch_both_parts(
word_forms_bases, _)
save_list_to_file(adjectives_ch_both_parts,
'Прил-ные с дефисом. Изм. обе части.txt',
encoding='cp1251')
print(f'Создан документ: Прил-ные с дефисом. Изм. обе части.txt')
print(f'... сортировка ...')
unusual_words = (
adjectives_ch_first_part
+ adjectives_ch_both_parts
)
word_forms = []
unique_elements = []
for group in word_forms_bases:
if (
group.title_word_form.idf.startswith('.П')
and str(group.title_word_form) not in unusual_words
):
elements = ' '.join(group.title_word_form.info)
if elements not in unique_elements:
unique_elements.append(elements)
word_forms.append(group.title_word_form)
in_form_of_list = []
for form in word_forms:
indicators = OrderedDict({
'name': form.name,
# 'idf': form.idf,
'I': '',
'К': '',
'С': '',
'П': '',
'о': '',
'е': '',
})
for indicator in form.info:
if indicator.startswith('I'):
indicators['I'] = indicator
elif indicator.startswith('К'):
indicators['К'] = indicator
elif indicator.startswith('С'):
indicators['С'] = indicator
elif indicator.startswith('П'):
indicators['П'] = indicator
elif indicator == 'о':
indicators['о'] = indicator
elif indicator == 'е':
indicators['е'] = indicator
in_form_of_list.append(list(indicators.values()))
in_form_of_list = sorted(
in_form_of_list,
key=lambda x: (x[1], x[2], x[3], x[4], x[5], x[6])
)
head_1 = [
'',
'полная\nформа',
'краткая\nформа',
'сравнительная\nстепень',
'превосходная\nстепень',
'одушевлённость',
'только\nединственное\nчисло',
]
head_2 = [
'',
'НЕ образуется для\nадъектированных причастий и\nГОРАЗД, РАД,\nПОЛНЫМ-ПОЛОН',
'Новое прилагательное,\nобразующее краткую форму,\nнужно внести в список 12',
'Новое прилагательное,\nобразующее сравнительную степень,\nнужно внести в список 22',
'Новое прилагательное,\nобразующее превосходную степень,\nнужно внести в список 27',
'', '',
]
in_form_of_list = [head_1] + [head_2] + in_form_of_list
print(f'\n{reminder_nouns}\n')
save_list_of_lists_to_csv_file(
in_form_of_list,
'Прилагательные. Сочетания шаблонов.csv',
encoding='cp1251',
delimiter=';'
)
def get_ordinary_words_bg(word_forms_bases, socket_group_list) -> list:
"""
Удалить из БГ строки из документов:
Невидимки.txt ;
Многокорневые слова БГ.csv ;
Повторы в гнезде. Повторяющиеся строки.txt ;
Повторы в гнезде. Уникальные строки.txt ;
Омонимы БГ.txt ;
Слова, омонимичные многокорневым словам.txt ;
Слова, омонимичные повторам в гнезде.txt .
Расположить оставшиеся строки в соответствии с алфавитным порядком слов,
без пробелов между строками.
Сохранить получившийся документ и
переименовать его в Обычные слова БГ.txt . Примечание. В 7 указанных документах могут быть одинаковые строки.
"""
# Невидимки.txt
invisible = get_invisible(word_forms_bases, socket_group_list)
save_list_to_file(invisible, 'Невидимки.txt', encoding='cp1251')
print(f'Создан документ: Невидимки.txt')
print(f'... сортировка ...')
# Многокорневые слова БГ.csv
save_multi_root_words(word_forms_bases, socket_group_list)
print(f'Создан документ: Многокорневые слова БГ.csv')
print(f'... сортировка ...')
multi_root_words = get_dicts_from_csv_file('Многокорневые слова БГ.csv')
multi_root_names = []
for multi_root_word in multi_root_words:
for root_index_key in list(multi_root_word):
if multi_root_word[root_index_key]:
multi_root_names.append(multi_root_word[root_index_key])
# Повторы в гнезде. Повторяющиеся строки.txt
replays_in_socket_duplicate = get_replays_in_socket_duplicate(
word_forms_bases, socket_group_list)
save_list_to_file(replays_in_socket_duplicate,
'Повторы в гнезде. Повторяющиеся строки.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в гнезде. Повторяющиеся строки.txt')
print(f'... сортировка ...')
# Повторы в гнезде. Уникальные строки.txt
replays_in_socket_unique = get_replays_in_socket_unique(
word_forms_bases, socket_group_list)
save_list_to_file(replays_in_socket_unique,
'Повторы в гнезде. Уникальные строки.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в гнезде. Уникальные строки.txt')
print(f'... сортировка ...')
# Омонимы БГ.txt
homonyms_bg = get_homonyms_bg(word_forms_bases, socket_group_list)
save_list_to_file(homonyms_bg, 'Омонимы БГ.txt', encoding='cp1251')
homonyms_bg = [x.split(' < ')[0] for x in homonyms_bg]
print(f'Создан документ: Омонимы БГ.txt')
print(f'... сортировка ...')
# Слова, омонимичные многокорневым словам.txt
homonymous_multi_rooted = get_homonymous_multi_rooted(
word_forms_bases, socket_group_list)
save_list_to_file(homonymous_multi_rooted,
'Слова, омонимичные многокорневым словам.txt',
encoding='cp1251')
homonymous_multi_rooted = [
x.split(' < ')[0] for x in homonymous_multi_rooted
]
print(f'Создан документ: Слова, омонимичные многокорневым словам.txt')
print(f'... сортировка ...')
# Слова, омонимичные повторам в гнезде.txt
homonymous_replays_in_socket = get_homonymous_replays_in_socket(
word_forms_bases, socket_group_list)
save_list_to_file(homonymous_replays_in_socket,
'Слова, омонимичные повторам в гнезде.txt',
encoding='cp1251')
homonymous_replays_in_socket = [
x.split(' < ')[0] for x in homonymous_replays_in_socket
]
print(f'Создан документ: Слова, омонимичные повторам в гнезде.txt')
print(f'... сортировка ...')
homonymous_replays_in_socket = [
x.split(' < ')[0] for x in homonymous_replays_in_socket
]
print('... ждите ...')
# Обычные слова БГ.txt
unusual_words = (invisible + multi_root_names +
replays_in_socket_duplicate + replays_in_socket_unique +
homonyms_bg + homonymous_multi_rooted +
homonymous_replays_in_socket)
word_forms = []
for socket_group in socket_group_list:
for sub_group in socket_group.sub_groups:
for word_form in sub_group.socket_word_forms:
if str(word_form) not in unusual_words:
word_forms.append(str(word_form))
word_forms = list(
sorted(word_forms, key=lambda x: x.replace('*', '').lower().strip()))
return word_forms
def get_homonymous_replays_in_socket(_, socket_group_list) -> list:
"""
Создать документы Повторы в пределах гнезда.txt
и Повторы в пределах гнезда. Строки.txt .
Найти в БГ в подгруппах, НЕ указанных в документе
Повторы в пределах гнезда.txt ,
строки со словами (кроме невидимок),
совпадающими по написанию со словами из документа
Повторы в пределах гнезда. Строки.txt .
Создать документ Слова, омонимичные повторам в гнезде.txt
и вставить в него найденные строки с соблюдением алфавитного порядка слов
и с соблюдением следующего правила:
если омоним является ЗС подгруппы,
то просто полностью указывается строка с омонимом;
если же омоним не является ЗС подгруппы,
то после строки с омонимом ставится символ <
и затем указывается строка с ЗС подгруппы,
в которой находится данный омоним.
"""
# Повторы в пределах гнезда. Строки.txt
replays_in_socket_strings = get_replays_in_socket_strings(
_, socket_group_list)
save_list_to_file(replays_in_socket_strings,
'Повторы в пределах гнезда. Строки.txt',
encoding='cp1251')
print(f'Создан документ: Повторы в пределах гнезда. Строки.txt')
print(f'... сортировка ...')
# Повторы в пределах гнезда.txt
replays_in_socket = get_string_list_from_file(
'Повторы в пределах гнезда.txt', encoding='cp1251')
# flag = True
# replays_in_socket_group = [
# x for x in replays_in_socket
# if (
# (flag, flag := not bool(x))[0]
# )
# ]
replays_in_socket_group = [
x[2:] for x in replays_in_socket if x.startswith('!')
]
# Слова, омонимичные повторам в гнезде.txt
word_forms = []
replays_in_socket_names = [
get_socket_word_form(x).name for x in replays_in_socket_strings
]
for socket_group in socket_group_list:
for sub_group in socket_group.sub_groups:
sub_title_word_form = sub_group.title_word_form
if str(sub_title_word_form) not in replays_in_socket_group:
for cnt, word_form in enumerate(sub_group.socket_word_forms):
if (not word_form.invisible
and word_form.name in replays_in_socket_names):
if not cnt:
word_forms.append(str(word_form))
else:
word_forms.append(f'{str(word_form)}'
' < '
f'{str(sub_title_word_form)}')
return sorted(word_forms)
def get_adjectives_ch_both_parts_identifiers(word_forms_bases, _) -> list:
"""
1. Создать документ Прил-ные с дефисом. Изм. обе части.txt .
2. Найти в БС группы с ЗС из документа
Прил-ные с дефисом. Изм. обе части.txt .
3. Создать документ
Прил-ные с дефисом. Изм. обе части. Идентификаторы.txt
и вставить в него все идентификаторы из найденных согласно п. 2 групп.
4. Удалить повторы одинаковых идентификаторов, оставив только уникальные.
5. Упорядочить идентификаторы следующим образом:
сначала с учётом формы
(сначала идентификаторы полной формы,
затем краткой формы, затем сравнительной степени,
затем превосходной степени);
затем с учётом числа (сначала идентификаторы единственного числа,
затем - множественного);
затем с учётом рода (сначала идентификаторы мужского рода,
затем женского, затем среднего);
затем учитывая порядок падежей: И Р Д В Т П ;
затем - в соответствии с алфавитным порядком
остальных элементов идентификаторов.
6. Сохранить документ
Прил-ные с дефисом. Изм. обе части. Идентификаторы.txt .
"""
# Прил-ные с дефисом. Изм. обе части.txt
adjectives_hyphenated = get_adjectives_hyphenated_ch_both_parts(
word_forms_bases, _)
save_list_to_file(adjectives_hyphenated,
'Прил-ные с дефисом. Изм. обе части.txt',
encoding='cp1251')
print(f'Создан документ: Прил-ные с дефисом. Изм. обе части.txt')
print(f'... сортировка ...')
pmi_idf = set() # .ПмИ
pmr_idf = set() # .ПмР
pmd_idf = set() # .ПмД
pmv_idf = set() # .ПмВ
pmt_idf = set() # .ПмТ
pmp_idf = set() # .ПмП
pzi_idf = set() # .ПжИ
pzr_idf = set() # .ПжР
pzd_idf = set() # .ПжД
pzv_idf = set() # .ПжВ
pzt_idf = set() # .ПжТ
pzp_idf = set() # .ПжП
psi_idf = set() # .ПсИ
psr_idf = set() # .ПсР
psd_idf = set() # .ПсД
psv_idf = set() # .ПсВ
pst_idf = set() # .ПсТ
psp_idf = set() # .ПсП
pmni_idf = set() # .ПмнИ
pmnr_idf = set() # .ПмнР
pmnd_idf = set() # .ПмнД
pmnv_idf = set() # .ПмнВ
pmnt_idf = set() # .ПмнТ
pmnp_idf = set() # .ПмнП
pkm_idf = set() # .ПКм
pkz_idf = set() # .ПКж
pks_idf = set() # .ПКс
pkmn_idf = set() # .ПКмн
ps_idf = set() # .ПС
ppmi_idf = set() # .ППмИ
ppmr_idf = set() # .ППмР
ppmd_idf = set() # .ППмД
ppmv_idf = set() # .ППмВ
ppmt_idf = set() # .ППмТ
ppmp_idf = set() # .ППмП
ppzi_idf = set() # .ППжИ
ppzr_idf = set() # .ППжР
ppzd_idf = set() # .ППжД
ppzv_idf = set() # .ППжВ
ppzt_idf = set() # .ППжТ
ppzp_idf = set() # .ППжП
ppsi_idf = set() # .ППсИ
ppsr_idf = set() # .ППсР
ppsd_idf = set() # .ППсД
ppsv_idf = set() # .ППсВ
ppst_idf = set() # .ППсТ
ppsp_idf = set() # .ППсП
ppmni_idf = set() # .ППмнИ
ppmnr_idf = set() # .ППмнР
ppmnd_idf = set() # .ППмнД
ppmnv_idf = set() # .ППмнВ
ppmnt_idf = set() # .ППмнТ
ppmnp_idf = set() # .ППмнП
identifiers = []
for group in word_forms_bases:
if str(group.title_word_form) in adjectives_hyphenated:
forms = [group.title_word_form] + group.word_forms
idfs = [x.idf for x in forms]
for identifier in idfs:
# полная форма
if identifier[2] not in ('К', 'С', 'П'):
if not identifier.find('мн') > 0:
if identifier.startswith('.ПмИ'):
pmi_idf.add(identifier)
elif identifier.startswith('.ПмР'):
pmr_idf.add(identifier)
elif identifier.startswith('.ПмД'):
pmd_idf.add(identifier)
elif identifier.startswith('.ПмВ'):
pmv_idf.add(identifier)
elif identifier.startswith('.ПмТ'):
pmt_idf.add(identifier)
elif identifier.startswith('.ПмП'):
pmp_idf.add(identifier)
elif identifier.startswith('.ПжИ'):
pzi_idf.add(identifier)
elif identifier.startswith('.ПжР'):
pzr_idf.add(identifier)
elif identifier.startswith('.ПжД'):
pzd_idf.add(identifier)
elif identifier.startswith('.ПжВ'):
pzv_idf.add(identifier)
elif identifier.startswith('.ПжТ'):
pzt_idf.add(identifier)
elif identifier.startswith('.ПжП'):
pzp_idf.add(identifier)
elif identifier.startswith('.ПсИ'):
psi_idf.add(identifier)
elif identifier.startswith('.ПсР'):
psr_idf.add(identifier)
elif identifier.startswith('.ПсД'):
psd_idf.add(identifier)
elif identifier.startswith('.ПсВ'):
psv_idf.add(identifier)
elif identifier.startswith('.ПсТ'):
pst_idf.add(identifier)
elif identifier.startswith('.ПсП'):
psp_idf.add(identifier)
else:
if identifier.startswith('.ПмнИ'):
pmni_idf.add(identifier)
elif identifier.startswith('.ПмнР'):
pmnr_idf.add(identifier)
elif identifier.startswith('.ПмнД'):
pmnd_idf.add(identifier)
elif identifier.startswith('.ПмнВ'):
pmnv_idf.add(identifier)
elif identifier.startswith('.ПмнТ'):
pmnt_idf.add(identifier)
elif identifier.startswith('.ПмнП'):
pmnp_idf.add(identifier)
# краткая форма
elif identifier[2] == 'К':
if not identifier.find('мн') > 0:
if identifier.startswith('.ПКм'):
pkm_idf.add(identifier)
elif identifier.startswith('.ПКж'):
pkz_idf.add(identifier)
elif identifier.startswith('.ПКс'):
pks_idf.add(identifier)
elif identifier.startswith('.ПКмн'):
pkmn_idf.add(identifier)
# сравинтельная степень
elif identifier[2] == 'С':
ps_idf.add(identifier)
# превосходная степень
elif identifier[2] == 'П':
if not identifier.find('мн') > 0:
if identifier.startswith('.ППмИ'):
ppmi_idf.add(identifier)
elif identifier.startswith('.ППмР'):
ppmr_idf.add(identifier)
elif identifier.startswith('.ППмД'):
ppmd_idf.add(identifier)
elif identifier.startswith('.ППмВ'):
ppmv_idf.add(identifier)
elif identifier.startswith('.ППмТ'):
ppmt_idf.add(identifier)
elif identifier.startswith('.ППмП'):
ppmp_idf.add(identifier)
elif identifier.startswith('.ППжИ'):
ppzi_idf.add(identifier)
elif identifier.startswith('.ППжР'):
ppzr_idf.add(identifier)
elif identifier.startswith('.ППжД'):
ppzd_idf.add(identifier)
elif identifier.startswith('.ППжВ'):
ppzv_idf.add(identifier)
elif identifier.startswith('.ППжТ'):
ppzt_idf.add(identifier)
elif identifier.startswith('.ППжП'):
ppzp_idf.add(identifier)
elif identifier.startswith('.ППсИ'):
ppsi_idf.add(identifier)
elif identifier.startswith('.ППсР'):
ppsr_idf.add(identifier)
elif identifier.startswith('.ППсД'):
ppsd_idf.add(identifier)
elif identifier.startswith('.ППсВ'):
ppsv_idf.add(identifier)
elif identifier.startswith('.ППсТ'):
ppst_idf.add(identifier)
elif identifier.startswith('.ППсП'):
ppsp_idf.add(identifier)
else:
if identifier.startswith('.ППмнИ'):
ppmni_idf.add(identifier)
elif identifier.startswith('.ППмнР'):
ppmnr_idf.add(identifier)
elif identifier.startswith('.ППмнД'):
ppmnd_idf.add(identifier)
elif identifier.startswith('.ППмнВ'):
ppmnv_idf.add(identifier)
elif identifier.startswith('.ППмнТ'):
ppmnt_idf.add(identifier)
elif identifier.startswith('.ППмнП'):
ppmnp_idf.add(identifier)
identifiers += sorted(list(pmi_idf))
identifiers += sorted(list(pmr_idf))
identifiers += sorted(list(pmd_idf))
identifiers += sorted(list(pmv_idf))
identifiers += sorted(list(pmt_idf))
identifiers += sorted(list(pmp_idf))
identifiers += sorted(list(pzi_idf))
identifiers += sorted(list(pzr_idf))
identifiers += sorted(list(pzd_idf))
identifiers += sorted(list(pzv_idf))
identifiers += sorted(list(pzt_idf))
identifiers += sorted(list(pzp_idf))
identifiers += sorted(list(psi_idf))
identifiers += sorted(list(psr_idf))
identifiers += sorted(list(psd_idf))
identifiers += sorted(list(psv_idf))
identifiers += sorted(list(pst_idf))
identifiers += sorted(list(psp_idf))
identifiers += sorted(list(pmni_idf))
identifiers += sorted(list(pmnr_idf))
identifiers += sorted(list(pmnd_idf))
identifiers += sorted(list(pmnv_idf))
identifiers += sorted(list(pmnt_idf))
identifiers += sorted(list(pmnp_idf))
identifiers += sorted(list(pkm_idf))
identifiers += sorted(list(pkz_idf))
identifiers += sorted(list(pks_idf))
identifiers += sorted(list(pkmn_idf))
identifiers += sorted(list(ps_idf))
identifiers += sorted(list(ppmi_idf))
identifiers += sorted(list(ppmr_idf))
identifiers += sorted(list(ppmd_idf))
identifiers += sorted(list(ppmv_idf))
identifiers += sorted(list(ppmt_idf))
identifiers += sorted(list(ppmp_idf))
identifiers += sorted(list(ppzi_idf))
identifiers += sorted(list(ppzr_idf))
identifiers += sorted(list(ppzd_idf))
identifiers += sorted(list(ppzv_idf))
identifiers += sorted(list(ppzt_idf))
identifiers += sorted(list(ppzp_idf))
identifiers += sorted(list(ppsi_idf))
identifiers += sorted(list(ppsr_idf))
identifiers += sorted(list(ppsd_idf))
identifiers += sorted(list(ppsv_idf))
identifiers += sorted(list(ppst_idf))
identifiers += sorted(list(ppsp_idf))
identifiers += sorted(list(ppmni_idf))
identifiers += sorted(list(ppmnr_idf))
identifiers += sorted(list(ppmnd_idf))
identifiers += sorted(list(ppmnv_idf))
identifiers += sorted(list(ppmnt_idf))
identifiers += sorted(list(ppmnp_idf))
return identifiers
def get_verbs_identifiers(word_forms_bases, _) -> list:
"""
1. Создать документ Глаголы с дефисом.txt .
2. Найти в БС группы с ЗС, идентификатор которых содержит .Г
(кроме ЗС из документа Глаголы с дефисом.txt).
3. Создать документ Глаголы. Идентификаторы.txt и вставить в него
все идентификаторы из найденных согласно п. 2 групп.
4. Удалить повторы одинаковых идентификаторов, оставив только уникальные.
5. Упорядочить идентификаторы следующим образом:
сначала учитывая порядок форм (сначала идентификаторы инфинитива,
затем настоящего / будущего времени, затем прошедшего времени и т. д.):
И НБ П Пв СД ПНД ПНС ППД ППС ДН ДП ;
затем с учётом числа (сначала идентификаторы единственного числа,
затем - множественного);
затем с учётом лица (сначала идентификаторы 1-ого лица, затем 2-ого,
затем 3-его) - только для форм настоящего / будущего времени;
затем с учётом рода (сначала идентификаторы мужского рода,
затем женского, затем среднего);
затем учитывая порядок падежей: И Р Д В Т П ;
затем - в соответствии с алфавитным порядком
остальных элементов идентификаторов.
6. Сохранить документ Глаголы. Идентификаторы.txt .
"""
# Глаголы с дефисом.txt
verbs_hyphenated = get_verbs_hyphenated(word_forms_bases, _)
save_list_to_file(verbs_hyphenated,
'Глаголы с дефисом.txt',
encoding='cp1251')
print(f'Создан документ: Глаголы с дефисом.txt')
print(f'... сортировка ...')
gi_idf = set() # .ГИ
gnb_idf = set() # .ГНБ
gp_idf = set() # .ГП
gpmn_idf = set() # .ГПмн
gpv_idf = set() # .ГПв
gsd_idf = set() # .ГСД
pnd_idf = set() # .ПНД
pnd_mn_idf = set() # .ПНДмн
pnd1_idf = set() # .ПНД1
pnd1_mn_idf = set() # .ПНД1мн
pnd2_idf = set() # .ПНД2
pnd2_mn_idf = set() # .ПНД2мн
pndk_idf = set() # .ПНДК
pndk_mn_idf = set() # .ПНДКмн
pns_idf = set() # .ПНС
pns_mn_idf = set() # .ПНСмн
pns1_idf = set() # .ПНС1
pns1_mn_idf = set() # .ПНС1мн
pns2_idf = set() # .ПНС2
pns2_mn_idf = set() # .ПНС2мн
pnsk_idf = set() # .ПНСК
pnsk_mn_idf = set() # .ПНСКмн
ppd_idf = set() # .ППД
ppd_mn_idf = set() # .ППДмн
ppd1_idf = set() # .ППД1
ppd1_mn_idf = set() # .ППД1мн
ppd2_idf = set() # .ППД2
ppd2_mn_idf = set() # .ППД2мн
pps_idf = set() # .ППС
pps_mn_idf = set() # .ППСмн
pps1_idf = set() # .ППС1
pps1_mn_idf = set() # .ППС1мн
pps2_idf = set() # .ППС2
pps2_mn_idf = set() # .ППС2мн
ppsk_idf = set() # .ППСК
ppsk_mn_idf = set() # .ППСКмн
dn_idf = set() # .ДН
dp_idf = set() # .ДП
identifiers = []
for group in word_forms_bases:
if (str(group.title_word_form) not in verbs_hyphenated
and group.title_word_form.idf.startswith('.Г')):
forms = [group.title_word_form] + group.word_forms
idfs = [x.idf for x in forms]
for identifier in idfs:
if identifier.startswith('.ГИ'):
gi_idf.add(identifier)
elif identifier.startswith('.ГНБ'):
gnb_idf.add(identifier)
elif identifier.startswith('.ГПв'):
gpv_idf.add(identifier)
elif identifier.startswith('.ГПмн'):
gpmn_idf.add(identifier)
elif identifier.startswith('.ГП'):
gp_idf.add(identifier)
elif identifier.startswith('.ГСД'):
gsd_idf.add(identifier)
elif identifier.startswith('.ПНД1мн'):
pnd1_mn_idf.add(identifier)
elif identifier.startswith('.ПНД1'):
pnd1_idf.add(identifier)
elif identifier.startswith('.ПНД2мн'):
pnd2_mn_idf.add(identifier)
elif identifier.startswith('.ПНД2'):
pnd2_idf.add(identifier)
elif identifier.startswith('.ПНДКмн'):
pndk_mn_idf.add(identifier)
elif identifier.startswith('.ПНДК'):
pndk_idf.add(identifier)
elif identifier.startswith('.ПНДмн'):
pnd_mn_idf.add(identifier)
elif identifier.startswith('.ПНД'):
pnd_idf.add(identifier)
elif identifier.startswith('.ПНС1мн'):
pns1_mn_idf.add(identifier)
elif identifier.startswith('.ПНС1'):
pns1_idf.add(identifier)
elif identifier.startswith('.ПНС2мн'):
pns2_mn_idf.add(identifier)
elif identifier.startswith('.ПНС2'):
pns2_idf.add(identifier)
elif identifier.startswith('.ПНСКмн'):
pnsk_mn_idf.add(identifier)
elif identifier.startswith('.ПНСК'):
pnsk_idf.add(identifier)
elif identifier.startswith('.ПНСмн'):
pns_mn_idf.add(identifier)
elif identifier.startswith('.ПНС'):
pns_idf.add(identifier)
elif identifier.startswith('.ППД1мн'):
ppd1_mn_idf.add(identifier)
elif identifier.startswith('.ППД1'):
ppd1_idf.add(identifier)
elif identifier.startswith('.ППД2мн'):
ppd2_mn_idf.add(identifier)
elif identifier.startswith('.ППД2'):
ppd2_idf.add(identifier)
elif identifier.startswith('.ППДмн'):
ppd_mn_idf.add(identifier)
elif identifier.startswith('.ППД'):
ppd_idf.add(identifier)
elif identifier.startswith('.ППС1мн'):
pps1_mn_idf.add(identifier)
elif identifier.startswith('.ППС1'):
pps1_idf.add(identifier)
elif identifier.startswith('.ППС2мн'):
pps2_mn_idf.add(identifier)
elif identifier.startswith('.ППС2'):
pps2_idf.add(identifier)
elif identifier.startswith('.ППСКмн'):
ppsk_mn_idf.add(identifier)
elif identifier.startswith('.ППСК'):
ppsk_idf.add(identifier)
elif identifier.startswith('.ППСмн'):
pps_mn_idf.add(identifier)
elif identifier.startswith('.ППС'):
pps_idf.add(identifier)
elif identifier.startswith('.ДН'):
dn_idf.add(identifier)
elif identifier.startswith('.ДП'):
dp_idf.add(identifier)
identifiers += sorted(list(gi_idf))
identifiers += sorted(list(gnb_idf),
key=lambda x: (x[4], sorting_by_number[x[5]], x))
identifiers += sorted(list(gp_idf),
key=lambda x: (sorting_by_gender[x[3]], x))
identifiers += sorted(list(gpmn_idf))
identifiers += sorted(list(gpv_idf),
key=lambda x: (sorting_by_number[x[4]], x))
identifiers += sorted(list(gsd_idf))
identifiers += sorted(list(pnd_idf),
key=lambda x:
(sorting_by_gender[x[4]], sorting_by_case[x[5]], x))
identifiers += sorted(list(pnd_mn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd1_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd1_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pnd2_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd2_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pndk_idf),
key=lambda x: (sorting_by_gender[x[5]], x))
identifiers += sorted(list(pndk_mn_idf))
identifiers += sorted(list(pns_idf),
key=lambda x:
(sorting_by_gender[x[4]], sorting_by_case[x[5]], x))
identifiers += sorted(list(pns_mn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pns1_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(pns1_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pns2_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(pns2_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pnsk_idf),
key=lambda x: (sorting_by_gender[x[5]], x))
identifiers += sorted(list(pnsk_mn_idf))
identifiers += sorted(list(ppd_idf),
key=lambda x:
(sorting_by_gender[x[4]], sorting_by_case[x[5]], x))
identifiers += sorted(list(ppd_mn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd1_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd1_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(ppd2_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd2_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pps_idf),
key=lambda x:
(sorting_by_gender[x[4]], sorting_by_case[x[5]], x))
identifiers += sorted(list(pps_mn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pps1_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(pps1_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pps2_idf),
key=lambda x:
(sorting_by_gender[x[5]], sorting_by_case[x[6]], x))
identifiers += sorted(list(pps2_mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(ppsk_idf),
key=lambda x: (sorting_by_gender[x[5]], x))
identifiers += sorted(list(ppsk_mn_idf))
identifiers += sorted(list(dn_idf))
identifiers += sorted(list(dp_idf))
return identifiers
def get_verbs_hyphenated_identifiers(word_forms_bases, _) -> list:
"""
1. Создать документ Глаголы с дефисом.txt .
2. Найти в БС группы с ЗС из документа Глаголы с дефисом.txt .
3. Создать документ Глаголы с дефисом. Идентификаторы.txt
и вставить в него все идентификаторы из найденных согласно п. 2 групп.
4. Удалить повторы одинаковых идентификаторов, оставив только уникальные.
5. Упорядочить идентификаторы следующим образом:
сначала учитывая порядок форм (сначала идентификаторы инфинитива,
затем настоящего / будущего времени,
затем прошедшего времени и т. д.): И НБ П Пв СД ПНД ПНС ППД ППС ДН ДП ;
затем с учётом числа (сначала идентификаторы единственного числа,
затем - множественного);
затем с учётом лица (сначала идентификаторы 1-ого лица, затем 2-ого,
затем 3-его) - только для форм настоящего / будущего времени;
затем с учётом рода (сначала идентификаторы мужского рода,
затем женского, затем среднего);
затем учитывая порядок падежей: И Р Д В Т П ;
затем - в соответствии с алфавитным порядком
остальных элементов идентификаторов.
6. Сохранить документ Глаголы с дефисом. Идентификаторы.txt .
"""
# Глаголы с дефисом.txt
verbs_hyphenated = get_verbs_hyphenated(word_forms_bases, _)
save_list_to_file(verbs_hyphenated,
'Глаголы с дефисом.txt',
encoding='cp1251')
print(f'Создан документ: Глаголы с дефисом.txt')
print(f'... сортировка ...')
gi_idf = set() # .ГИ
gnb_e_idf = set() # .ГНБ<*>е
gnb_mn_idf = set() # .ГНБ<*>мн
gp_idf = set() # .ГП
gpv_idf = set() # .ГПв
gs_idf = set() # .ГС
pndm_idf = set() # .ПНДм
pndz_idf = set() # .ПНДж
pnds_idf = set() # .ПНДс
pndmn_idf = set() # .ПНДмн
pndk_idf = set() # .ПНДК
pnd1m_idf = set() # .ПНД1м
pnd1z_idf = set() # .ПНД1ж
pnd1s_idf = set() # .ПНД1с
pnd1mn_idf = set() # .ПНД1мн
pnd2m_idf = set() # .ПНД2м
pnd2z_idf = set() # .ПНД2ж
pnd2s_idf = set() # .ПНД2с
pnd2mn_idf = set() # .ПНД2мн
pnsm_idf = set() # .ПНСм
pnsz_idf = set() # .ПНСж
pnss_idf = set() # .ПНСс
pnsmn_idf = set() # .ПНСмн
pnsk_idf = set() # .ПНСКм
pns1m_idf = set() # .ПНС1м
pns1z_idf = set() # .ПНС1ж
pns1s_idf = set() # .ПНС1с
pns1mn_idf = set() # .ПНС1мн
pns2m_idf = set() # .ПНС2м
pns2z_idf = set() # .ПНС2ж
pns2s_idf = set() # .ПНС2с
pns2mn_idf = set() # .ПНС2мн
ppdm_idf = set() # .ППДм
ppdz_idf = set() # .ППДж
ppds_idf = set() # .ППДс
ppdmn_idf = set() # .ППДмн
ppd1m_idf = set() # .ППД1м
ppd1z_idf = set() # .ППД1ж
ppd1s_idf = set() # .ППД1с
ppd1mn_idf = set() # .ППД1мн
ppd2m_idf = set() # .ППД2м
ppd2z_idf = set() # .ППД2ж
ppd2s_idf = set() # .ППД2с
ppd2mn_idf = set() # .ППД2мн
ppsm_idf = set() # .ППСм
ppsz_idf = set() # .ППСж
ppss_idf = set() # .ППСс
ppsmn_idf = set() # .ППСмн
pps1m_idf = set() # .ППС1м
pps1z_idf = set() # .ППС1ж
pps1s_idf = set() # .ППС1с
pps1mn_idf = set() # .ППС1мн
pps2m_idf = set() # .ППС2м
pps2z_idf = set() # .ППС2ж
pps2s_idf = set() # .ППС2с
pps2mn_idf = set() # .ППС2мн
ppsk_idf = set() # .ППСКм
dn_idf = set() # .ДН
dp_idf = set() # .ДП
identifiers = []
for group in word_forms_bases:
if str(group.title_word_form) in verbs_hyphenated:
forms = [group.title_word_form] + group.word_forms
idfs = [x.idf for x in forms]
for identifier in idfs:
if identifier.startswith('.ГИ'):
gi_idf.add(identifier)
elif re.match(r'.ГНБ\dе', identifier):
gnb_e_idf.add(identifier)
elif re.match(r'.ГНБ\dмн', identifier):
gnb_mn_idf.add(identifier)
elif identifier.startswith('.ГПв'):
gpv_idf.add(identifier)
elif identifier.startswith('.ГС'):
gs_idf.add(identifier)
elif (identifier.startswith('.ПНД1м')
and not identifier.startswith('.ПНД1мн')):
pnd1m_idf.add(identifier)
elif identifier.startswith('.ПНД1ж'):
pnd1z_idf.add(identifier)
elif identifier.startswith('.ПНД1с'):
pnd1s_idf.add(identifier)
elif identifier.startswith('.ПНД1мн'):
pnd1mn_idf.add(identifier)
elif (identifier.startswith('.ПНД2м')
and not identifier.startswith('.ПНД2мн')):
pnd2m_idf.add(identifier)
elif identifier.startswith('.ПНД2ж'):
pnd2z_idf.add(identifier)
elif identifier.startswith('.ПНД2с'):
pnd2s_idf.add(identifier)
elif identifier.startswith('.ПНД2мн'):
pnd2mn_idf.add(identifier)
elif identifier.startswith('.ПНДК'):
pndk_idf.add(identifier)
elif (identifier.startswith('.ПНДм')
and not identifier.startswith('.ПНДмн')):
pndm_idf.add(identifier)
elif identifier.startswith('.ПНДж'):
pndz_idf.add(identifier)
elif identifier.startswith('.ПНДс'):
pnds_idf.add(identifier)
elif identifier.startswith('.ПНДмн'):
pndmn_idf.add(identifier)
elif (identifier.startswith('.ПНС1м')
and not identifier.startswith('.ПНС1мн')):
pns1m_idf.add(identifier)
elif identifier.startswith('.ПНС1ж'):
pns1z_idf.add(identifier)
elif identifier.startswith('.ПНС1с'):
pns1s_idf.add(identifier)
elif identifier.startswith('.ПНС1мн'):
pns1mn_idf.add(identifier)
elif (identifier.startswith('.ПНС2м')
and not identifier.startswith('.ПНС2мн')):
pns2m_idf.add(identifier)
elif identifier.startswith('.ПНС2ж'):
pns2z_idf.add(identifier)
elif identifier.startswith('.ПНС2с'):
pns2s_idf.add(identifier)
elif identifier.startswith('.ПНС2мн'):
pns2mn_idf.add(identifier)
elif identifier.startswith('.ПНСК'):
pnsk_idf.add(identifier)
elif (identifier.startswith('.ПНСм')
and not identifier.startswith('.ПНСмн')):
pnsm_idf.add(identifier)
elif identifier.startswith('.ПНСж'):
pnsz_idf.add(identifier)
elif identifier.startswith('.ПНСс'):
pnss_idf.add(identifier)
elif identifier.startswith('.ПНСмн'):
pnsmn_idf.add(identifier)
elif (identifier.startswith('.ППД1м')
and not identifier.startswith('.ППД1мн')):
ppd1m_idf.add(identifier)
elif identifier.startswith('.ППД1ж'):
ppd1z_idf.add(identifier)
elif identifier.startswith('.ППД1с'):
ppd1s_idf.add(identifier)
elif identifier.startswith('.ППД1мн'):
ppd1mn_idf.add(identifier)
elif (identifier.startswith('.ППД2м')
and not identifier.startswith('.ППД2мн')):
ppd2m_idf.add(identifier)
elif identifier.startswith('.ППД2ж'):
ppd2z_idf.add(identifier)
elif identifier.startswith('.ППД2с'):
ppd2s_idf.add(identifier)
elif identifier.startswith('.ППД2мн'):
ppd2mn_idf.add(identifier)
elif (identifier.startswith('.ППДм')
and not identifier.startswith('.ППДмн')):
ppdm_idf.add(identifier)
elif identifier.startswith('.ППДж'):
ppdz_idf.add(identifier)
elif identifier.startswith('.ППДс'):
ppds_idf.add(identifier)
elif identifier.startswith('.ППДмн'):
ppdmn_idf.add(identifier)
elif (identifier.startswith('.ППС1м')
and not identifier.startswith('.ППС1мн')):
pps1m_idf.add(identifier)
elif identifier.startswith('.ППС1ж'):
pps1z_idf.add(identifier)
elif identifier.startswith('.ППС1с'):
pps1s_idf.add(identifier)
elif identifier.startswith('.ППС1мн'):
pps1mn_idf.add(identifier)
elif (identifier.startswith('.ППС2м')
and not identifier.startswith('.ППС2мн')):
pps2m_idf.add(identifier)
elif identifier.startswith('.ППС2ж'):
pps2z_idf.add(identifier)
elif identifier.startswith('.ППС2с'):
pps2s_idf.add(identifier)
elif identifier.startswith('.ППС2мн'):
pps2mn_idf.add(identifier)
elif identifier.startswith('.ППСК'):
ppsk_idf.add(identifier)
elif (identifier.startswith('.ППСм')
and not identifier.startswith('.ППСмн')):
ppsm_idf.add(identifier)
elif identifier.startswith('.ППСж'):
ppsz_idf.add(identifier)
elif identifier.startswith('.ППСс'):
ppss_idf.add(identifier)
elif identifier.startswith('.ППСмн'):
ppsmn_idf.add(identifier)
elif identifier.startswith('.ДН'):
dn_idf.add(identifier)
elif identifier.startswith('.ДП'):
dp_idf.add(identifier)
elif identifier.startswith('.ГП'):
gp_idf.add(identifier)
identifiers += sorted(list(gi_idf))
identifiers += sorted(list(gnb_e_idf))
identifiers += sorted(list(gnb_mn_idf))
identifiers += sorted(list(gp_idf),
key=lambda x: sorting_by_gender[x.split('-')[0][3:]])
identifiers += sorted(list(gpv_idf))
identifiers += sorted(list(gs_idf))
identifiers += sorted(list(pndm_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(pndz_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(pnds_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(pndmn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pndk_idf),
key=lambda x: (sorting_by_gender[x[5]], x))
identifiers += sorted(list(pnd1m_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd1z_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd1s_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd1mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pnd2m_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd2z_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd2s_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnd2mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pnsm_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(pnsz_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(pnss_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(pnsmn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pnsk_idf),
key=lambda x: (sorting_by_gender[x[5]], x))
identifiers += sorted(list(pns1m_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pns1z_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pns1s_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pns1mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(pns2m_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pns2z_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pns2s_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pns2mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(ppdm_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(ppdz_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(ppds_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(ppdmn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd1m_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd1z_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd1s_idf),
key=lambda x: (sorting_by_case[x[6]]))
identifiers += sorted(list(ppd1mn_idf),
key=lambda x: (sorting_by_case[x[7]]))
identifiers += sorted(list(ppd2m_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd2z_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd2s_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(ppd2mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(ppsm_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(ppsz_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(ppss_idf),
key=lambda x: (sorting_by_case[x[5]], x))
identifiers += sorted(list(ppsmn_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pps1m_idf),
key=lambda x: sorting_by_case[x[6:]])
identifiers += sorted(list(pps1z_idf),
key=lambda x: sorting_by_case[x[6:]])
identifiers += sorted(list(pps1s_idf),
key=lambda x: sorting_by_case[x[6:]])
identifiers += sorted(list(pps1mn_idf),
key=lambda x: sorting_by_case[x[7:]])
identifiers += sorted(list(pps2m_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pps2z_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pps2s_idf),
key=lambda x: (sorting_by_case[x[6]], x))
identifiers += sorted(list(pps2mn_idf),
key=lambda x: (sorting_by_case[x[7]], x))
identifiers += sorted(list(ppsk_idf),
key=lambda x: (sorting_by_gender[x[5]], x))
identifiers += sorted(list(dn_idf))
identifiers += sorted(list(dp_idf), reverse=True)
return identifiers
def get_nouns_identifiers(word_forms_bases, _) -> list:
"""1. Создать документ Сущ-ные с дефисом. Изм. обе части.txt .
2. Найти в БС группы с ЗС, идентификатор которых содержит .С
(кроме ЗС из документа Сущ-ные с дефисом. Изм. обе части.txt).
3. Создать документ Существительные. Идентификаторы.txt
и вставить в него все идентификаторы из найденных согласно п. 2 групп.
4. Удалить повторы одинаковых идентификаторов, оставив только уникальные.
5. Упорядочить идентификаторы следующим образом:
сначала с учётом числа (сначала идентификаторы единственного числа,
затем - множественного);
затем учитывая порядок падежей: И Р Д В Т П ;
затем - в соответствии с алфавитным порядком
остальных элементов идентификаторов.
6. Сохранить документ Существительные. Идентификаторы.txt ."""
# Сущ-ные с дефисом. Изм. обе части.txt
nouns_ch_both_parts = get_nouns_hyphenated_ch_both_parts(
word_forms_bases, _)
save_list_to_file(nouns_ch_both_parts,
'Сущ-ные с дефисом. Изм. обе части.txt',
encoding='cp1251')
print(f'Создан документ: Сущ-ные с дефисом. Изм. обе части.txt')
print(f'... сортировка ...')
sei_idf = set() # .СеИ
ser_idf = set() # .СеР
sed_idf = set() # .СеД
sev_idf = set() # .СеВ
set_idf = set() # .СеТ
sep_idf = set() # .СеП
smni_idf = set() # .СмнИ
smnr_idf = set() # .СмнР
smnd_idf = set() # .СмнД
smnv_idf = set() # .СмнВ
smnt_idf = set() # .СмнТ
smnp_idf = set() # .СмнП
identifiers = []
for group in word_forms_bases:
if (str(group.title_word_form) not in nouns_ch_both_parts
and group.title_word_form.idf.startswith('.С')):
forms = [group.title_word_form] + group.word_forms
idfs = [x.idf for x in forms]
for identifier in idfs:
if identifier.startswith('.СеИ'):
sei_idf.add(identifier)
elif identifier.startswith('.СеР'):
ser_idf.add(identifier)
elif identifier.startswith('.СеД'):
sed_idf.add(identifier)
elif identifier.startswith('.СеВ'):
sev_idf.add(identifier)
elif identifier.startswith('.СеТ'):
set_idf.add(identifier)
elif identifier.startswith('.СеП'):
sep_idf.add(identifier)
elif identifier.startswith('.СмнИ'):
smni_idf.add(identifier)
elif identifier.startswith('.СмнР'):
smnr_idf.add(identifier)
elif identifier.startswith('.СмнД'):
smnd_idf.add(identifier)
elif identifier.startswith('.СмнВ'):
smnv_idf.add(identifier)
elif identifier.startswith('.СмнТ'):
smnt_idf.add(identifier)
elif identifier.startswith('.СмнП'):
smnp_idf.add(identifier)
identifiers += sorted(list(sei_idf))
identifiers += sorted(list(ser_idf))
identifiers += sorted(list(sed_idf))
identifiers += sorted(list(sev_idf))
identifiers += sorted(list(set_idf))
identifiers += sorted(list(sep_idf))
identifiers += sorted(list(smni_idf))
identifiers += sorted(list(smnr_idf))
identifiers += sorted(list(smnd_idf))
identifiers += sorted(list(smnv_idf))
identifiers += sorted(list(smnt_idf))
identifiers += sorted(list(smnp_idf))
return identifiers
def train(opt, tr_dataloader, model, optim, lr_scheduler, val_dataloader=None):
'''
Train the model with the prototypical learning algorithm
'''
device = 'cuda:{}'.format(
opt.gpu_id) if torch.cuda.is_available() and opt.cuda else 'cpu'
if val_dataloader is None:
best_state = None
train_loss = []
train_acc = []
val_loss = []
val_acc = []
best_acc = 0
best_model_path = os.path.join(opt.experiment_root, 'best_model.pth')
last_model_path = os.path.join(opt.experiment_root, 'last_model.pth')
for epoch in range(opt.epochs):
print('=== Epoch: {} ==='.format(epoch))
tr_iter = iter(tr_dataloader)
model.train()
for batch in tqdm(tr_iter):
optim.zero_grad()
x, y = batch
x, y = x.to(device), y.to(device)
model_output = model(x)
loss, acc = loss_fn(model_output,
target=y,
n_support=opt.num_support_tr)
loss.backward()
optim.step()
train_loss.append(loss.item())
train_acc.append(acc.item())
avg_loss = np.mean(train_loss[-opt.iterations:])
avg_acc = np.mean(train_acc[-opt.iterations:])
print('Avg Train Loss: {}, Avg Train Acc: {}'.format(
avg_loss, avg_acc))
lr_scheduler.step()
if val_dataloader is None:
continue
val_iter = iter(val_dataloader)
model.eval()
for batch in val_iter:
x, y = batch
x, y = x.to(device), y.to(device)
model_output = model(x)
loss, acc = loss_fn(model_output,
target=y,
n_support=opt.num_support_val)
val_loss.append(loss.item())
val_acc.append(acc.item())
avg_loss = np.mean(val_loss[-opt.iterations:])
avg_acc = np.mean(val_acc[-opt.iterations:])
postfix = ' (Best)' if avg_acc >= best_acc else ' (Best: {})'.format(
best_acc)
print('Avg Val Loss: {}, Avg Val Acc: {}{}'.format(
avg_loss, avg_acc, postfix))
if avg_acc >= best_acc:
torch.save(model.state_dict(), best_model_path)
best_acc = avg_acc
best_state = model.state_dict()
torch.save(model.state_dict(), last_model_path)
for name in ['train_loss', 'train_acc', 'val_loss', 'val_acc']:
utils.save_list_to_file(
os.path.join(opt.experiment_root, name + '.txt'),
locals()[name])
return best_state, best_acc, train_loss, train_acc, val_loss, val_acc
def save_groups_to_bs():
definitions = 'WordFormGen. Существительные.txt'
print(f'Настройки:')
print(f'{definitions}\n')
*in_nouns_list, out_nouns = [
x for x in list(
get_string_list_from_file(definitions, encoding='cp1251')) if x
]
print(f'Файлы с исходными данными:')
for line in in_nouns_list:
print(line)
print()
print('Для продолжения нажмите Enter')
input()
print(f'{"* " * 38}*\n')
count = 0
add_groups_to_bs_list = []
add_groups_to_bg_list = []
error_list = []
for in_nouns in in_nouns_list:
src_groups = get_long_dicts_from_csv_file(in_nouns, num_fields=8)
for src_dict in src_groups:
try:
group_word_form = get_group_word_form(src_dict)
add_groups_to_bs_list.append(group_word_form)
add_groups_to_bg_list.append(
group_word_form.title_word_form.conformity_form)
count += 1
except KeyError as e:
error_list.append('В Н И М А Н И Е !\n'
'Аварийное завершение.\n'
f'Несуществующий шаблон: {str(e)[1:-1]}\n'
'Для продолжения нажмите Enter')
except InputDataError as e:
error_list.append(get_error_message(e))
if error_list:
for line in error_list:
print(line)
input()
print(f'Количество ошибок: {len(error_list)}')
print('Для выхода нажмите Enter')
input()
sys.exit()
save_bs_dicts_to_txt(sorted(add_groups_to_bs_list), out_nouns)
print(f'Создано {count} групп словоформ')
print(f'Создан файл "{out_nouns}"')
add_to_bg = 'Добавить в БГ. Существительные.txt'
save_list_to_file(sorted(add_groups_to_bg_list,
key=lambda x: x.replace('*', '').lower()),
add_to_bg,
encoding='cp1251')
print(f'Создан файл "{add_to_bg}"\n')
print(f'Файлы с результатами сохранены в текущей директории:')
print(Path().resolve())
print()
print('Для продолжения нажмите Enter')
input()
print(f'{reminder}\n')
print('Для выхода нажмите Enter')
input()
