Update app.py

app.py

@@ -909,35 +909,56 @@ def reset_button_text_2():
 
 def check_source_fields(description, product_name, benefits, key_message):
     results = []
+    exceptions_dict = {
+        "forbidden_words": set(),
+        "greetings": set(),
+        "promises": set(),
+        "double_verbs": set(),
+        "participles": set(),
+        "adverbial_participles": set(),
+        "superlative_adjectives": set(),
+        "passive_voice": set(),
+        "written_out_ordinals": set(),
+        "repeating_conjunctions": set(),
+        "introductory_phrases": set(),
+        "amplifiers": set(),
+        "time_parasites": set(),
+        "multiple_nouns": set(),
+        "derived_prepositions": set(),
+        "compound_sentences": set(),
+        "dates_written_out": set(),
+        "word_repetitions": set()
+    }
 
     # Проверяем "Описание предложения"
     desc_checks = perform_checks(description, "")
-    not_passed_desc = extract_failed_checks(desc_checks)
+    not_passed_desc = extract_failed_checks(desc_checks, exceptions_dict, context="Описание предложения")
     if not_passed_desc:
         results.append(f"Описание предложения:\n{not_passed_desc}")
 
     # Проверяем "Наименование продукта"
     name_checks = perform_checks(product_name, "")
-    not_passed_name = extract_failed_checks(name_checks)
+    not_passed_name = extract_failed_checks(name_checks, exceptions_dict, context="Наименование продукта")
     if not_passed_name:
         results.append(f"Наименование продукта:\n{not_passed_name}")
 
     # Проверяем "Преимущества"
     ben_checks = perform_checks(benefits, "")
-    not_passed_ben = extract_failed_checks(ben_checks)
+    not_passed_ben = extract_failed_checks(ben_checks, exceptions_dict, context="Преимущества")
     if not_passed_ben:
         results.append(f"Преимущества:\n{not_passed_ben}")
 
     # Проверяем "Ключевое сообщение"
     km_checks = perform_checks(key_message, "")
-    not_passed_km = extract_failed_checks(km_checks)
+    not_passed_km = extract_failed_checks(km_checks, exceptions_dict, context="Ключевое сообщение")
     if not_passed_km:
         results.append(f"Ключевое сообщение:\n{not_passed_km}")
 
     if not results:
-        return "Проверка исходных данных пройдена"
+        return "Проверка исходных данных пройдена", exceptions_dict
     else:
-        return "\n\n".join(results)
+        report = "\n\n".join(results)
+        return report, exceptions_dict
 
 
 def on_check_source_fields(description, product_name, benefits, key_message):
@@ -948,7 +969,16 @@ def on_check_source_fields(description, product_name, benefits, key_message):
 
 
 def extract_failed_checks(checks_dict):
+
+    morph = pymorphy3.MorphAnalyzer()
+
     lines = []
+
+    def lemma_pair(word1, word2):
+        p1 = morph.parse(word1)[0].normal_form
+        p2 = morph.parse(word2)[0].normal_form
+        return (p1, p2)
+
     for rule_key, result in checks_dict.items():
         # Определяем, было ли нарушение
         if isinstance(result, tuple):
@@ -989,12 +1019,29 @@ def rule_to_str(rule_key):
 
 # ФУНКЦИИ ПРОВЕРОК (НАЧАЛО)
 
+def lemmatize_word(word, morph):
+"""
+Возвращает (lemma, POS) для переданного слова.
+"""
+parsed = morph.parse(word)
+if not parsed:
+    return word, None
+best = parsed[0]
+return best.normal_form, best.tag.POS
+
 # 1. Запрещенные слова
 
-def check_forbidden_words(message):
-    morph = pymorphy3.MorphAnalyzer()
+def check_forbidden_words(message, exceptions=None):
+    """
+    Проверка на запрещённые слова.
+    Если лемма «запрещённого слова» находится в exceptions['forbidden_words'], 
+    то пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("forbidden_words", set())
 
-    # Перечень запрещённых слов и фраз
+    morph = pymorphy3.MorphAnalyzer()
     forbidden_patterns = [
         r'№\s?1\b', r'номер\sодин\b', r'номер\s1\b',
         r'вкусный', r'дешёвый', r'продукт',
@@ -1003,169 +1050,233 @@ def check_forbidden_words(message):
         r'гарантия', r'успех', r'лидер', 'никакой'
     ]
 
-    # Удаляем знаки препинания для корректного анализа
-    message_without_punctuation = message.translate(str.maketrans('', '', string.punctuation))
+    # Удаляем пунктуацию
+    message_no_punct = message.translate(str.maketrans('', '', string.punctuation))
 
-    # Замена всех слов, содержащих "бессроч", на временное значение
+    # Пример: «бессроч» => placeholder
     placeholder = "заменабессроч"
-    message_without_punctuation = re.sub(r'\b\w*бессроч\w*\b', placeholder, message_without_punctuation,
-                                         flags=re.IGNORECASE)
-
-    # Проверка на наличие подстроки "лучш" (без учета регистра)
-    if re.search(r'лучш', message_without_punctuation, re.IGNORECASE):
-        return (False, 'Есть слово "лучший"')
-
-    # Лемматизация слов сообщения
-    words = message_without_punctuation.split()
-    lemmas = [morph.parse(word)[0].normal_form for word in words]
+    message_no_punct = re.sub(r'\b\w*бессроч\w*\b', placeholder, message_no_punct, flags=re.IGNORECASE)
 
-    # Восстановление всех слов с подстрокой "бессроч"
-    lemmas = [re.sub(r'заменабессроч', 'бессроч', word) for word in lemmas]
-    normalized_message = ' '.join(lemmas)
+    # Лемматизируем все слова
+    words = message_no_punct.split()
+    lemmas = [morph.parse(w)[0].normal_form for w in words]
+    lemmas = [re.sub(r'заменабессроч', 'бессроч', l) for l in lemmas]
+    normalized_msg = ' '.join(lemmas)
 
-    # Проверка на запрещённые фразы и леммы
+    # Для каждого pattern проверяем, нет ли совпадения
     for pattern in forbidden_patterns:
-        if re.search(pattern, normalized_message, re.IGNORECASE):
-            print(f"Не пройдена проверка: Запрещенные слова. Сообщение: {message}")
-            return (False, f'Запрещенное слово: {pattern}')
+        found = re.search(pattern, normalized_msg, re.IGNORECASE)
+        if found:
+            # Получим саму найденную строку
+            matched_str = found.group(0)
+            # Лемматизируем
+            lemma_found, _ = lemmatize_word(matched_str, morph)
+            if lemma_found not in allowed_lemmas:
+                return False, f"Запрещенное слово: {matched_str}"
 
     return True
 
 
 # 2 и #3. Обращение к клиенту и приветствие клиента
 
-def check_no_greeting(message):
-    morph = pymorphy3.MorphAnalyzer()
-    # Список типичных обращений и приветствий
+def check_no_greeting(message, exceptions=None):
+    """
+    Проверка на «приветствия».
+    Если лемма слова среди exceptions['greetings'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("greetings", set())
+
     greeting_patterns = [
         r"привет\b", r"здравствуй", r"добрый\s(день|вечер|утро)",
         r"дорогой\b", r"уважаемый\b", r"дорогая\b", r"уважаемая\b",
         r"господин\b", r"госпожа\b", r"друг\b", r"коллега\b",
-        r"товарищ\b", r"приятель\b", r"друг\b", r"подруга\b"
+        r"товарищ\b", r"приятель\b", r"подруга\b"
     ]
-
-    # Компилируем все шаблоны в один регулярное выражение
-    greeting_regex = re.compile('|'.join(greeting_patterns), re.IGNORECASE)
-
-    # Проверяем, начинается ли сообщение с шаблона приветствия или обращения
-    if greeting_regex.search(message.strip()):
-        print(f"Не пройдена проверка: Обращение к клиенту и приветствие клиента. Сообщение: {message}")
-        return (False, 'Есть приветствие')
+    # Будем искать все совпадения паттернов
+    for pat in greeting_patterns:
+        match = re.search(pat, message, re.IGNORECASE)
+        if match:
+            found = match.group(0).lower()  # «дорогая», «привет» и т.п.
+            morph = pymorphy3.MorphAnalyzer()
+            lemma, pos = lemmatize_word(found, morph)
+            if lemma not in allowed_lemmas:
+                return False, f"Есть приветствие: {found}"
     return True
 
 
 # 4. Обещания и гарантии
 
-def check_no_promises(message):
+def check_no_promises(message, exceptions=None):
+    """
+    Проверка на «обещания».
+    Если lemma слова в exceptions['promises'], то пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("promises", set())
+
     morph = pymorphy3.MorphAnalyzer()
-    promise_patterns = [
-        "обещать", "обещание", "гарантировать", "обязаться", "обязать", "обязательство", "обязательный"
-    ]
+    patterns = ["обещать", "обещание", "гарантировать", "обязаться", "обязать", "обязательство", "обязательный"]
 
     words = message.split()
-    lemmas = [morph.parse(word)[0].normal_form for word in words]
+    lemmas = [morph.parse(w)[0].normal_form for w in words]
 
-    for pattern in promise_patterns:
-        if pattern in lemmas:
-            print(f"Не пройдена проверка: Обещания и гарантии. Сообщение: {message}")
-            return False, f'Не пройдена проверка: Обещания и гарантии:{pattern}'
+    for patt in patterns:
+        if patt in lemmas:
+            if patt not in allowed_lemmas:
+                return False, f"Не пройдена проверка: обещания => {patt}"
     return True
 
 
 # 5. Составные конструкции из двух глаголов
 
-def check_no_double_verbs(message):
+def check_no_double_verbs(message, exceptions=None):
+    """
+    Проверка на 2 подряд глагола.
+    Если (lemma1, lemma2) находится в exceptions['double_verbs'], то разрешаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_pairs = exceptions.get("double_verbs", set())
+
     morph = pymorphy3.MorphAnalyzer()
-    # Разделяем текст по пробелам и знакам препинания
     words = re.split(r'\s+|[.!?]', message)
-    morphs = [morph.parse(word)[0] for word in words]
-
-    for i in range(len(morphs) - 1):
-        # Проверяем, что оба слова являются глаголами (в любой форме, включая инфинитивы)
-        if (morphs[i].tag.POS in {'VERB', 'INFN'}) and (morphs[i + 1].tag.POS in {'VERB', 'INFN'}):
-            # Проверяем, является ли первый глагол "хотеть" или "начинать"
-            if morphs[i].normal_form in ['хотеть', 'начинать', 'начать']:
-                return True
-            else:
-                print(f"Не пройдена проверка: Составные конструкции из двух глаголов. Сообщение: {message}")
-                return False, f'Не пройдена проверка на составные конструкции из двух глаголов: {morphs[i].word} {morphs[i + 1].word}'
+
+    tokens = [w.strip() for w in words if w.strip()]
+    parses = [morph.parse(tok)[0] for tok in tokens]
+
+    for i in range(len(parses) - 1):
+        if (parses[i].tag.POS in {'VERB', 'INFN'}) and (parses[i+1].tag.POS in {'VERB', 'INFN'}):
+            lemma1 = parses[i].normal_form
+            lemma2 = parses[i+1].normal_form
+            pair = (lemma1, lemma2)
+            # Если разрешено
+            if pair in allowed_pairs:
+                continue
+            # Если это "хотеть", "начинать", ...
+            if lemma1 in ["хотеть", "начинать", "начать"]:
+                continue
+            return False, f"Не пройдена проверка на 2 глагола подряд: {parses[i].word} {parses[i+1].word}"
     return True
 
 
 # 6. Причастия и причастные обороты
 
-def check_no_participles(message):
+def check_no_participles(message, exceptions=None):
+    """
+    Проверка на причастия.
+    Если lemma причастия в exceptions['participles'], разрешаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("participles", set())
+
+    skip_lemmas = {"повысить", "увеличить", "понизить", "снизить"}
+
     morph = pymorphy3.MorphAnalyzer()
     words = message.split()
-    exceptions = {"повысить", "увеличить", "понизить", "снизить"}
-
-    for word in words:
-        parsed_word = morph.parse(word)[0]
-        lemma = parsed_word.normal_form
-        if 'PRTF' in parsed_word.tag and lemma not in exceptions:
-            print(f"Не пройдена проверка: Причастия и причастные обороты. Сообщение: {message}")
-            return False, f'Не пройдена проверка на причастия: {parsed_word.word}'
+
+    for w in words:
+        p = morph.parse(w)[0]
+        lemma = p.normal_form
+        if 'PRTF' in p.tag:
+            # Проверяем исключения
+            if lemma not in skip_lemmas and lemma not in allowed_lemmas:
+                return False, f"Не пройдена проверка на причастие: {p.word}"
     return True
 
 
 # 7. Деепричастия и деепричастные обороты
 
-def check_no_adverbial_participles(message):
+def check_no_adverbial_participles(message, exceptions=None):
+    """
+    Проверка на деепричастия. 
+    Если lemma в exceptions['adverbial_participles'], то не считае�� нарушением.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("adverbial_participles", set())
+
     morph = pymorphy3.MorphAnalyzer()
     words = message.split()
-    morphs = [morph.parse(word)[0] for word in words]
-
-    for morph in morphs:
-        if 'GRND' in morph.tag:
-            print(f"Не пройдена проверка: Деепричастия и деепричастные обороты. Сообщение: {message}")
-            return False, f'Не пройдена проверка на деепричастия: {morph.word}'
+    for w in words:
+        p = morph.parse(w)[0]
+        lemma = p.normal_form
+        if "GRND" in p.tag:
+            if lemma not in allowed_lemmas:
+                return False, f"Не пройдена проверка: деепричастие => {p.word}"
     return True
 
 
 # 8. Превосходная степень прилагательных
 
-def check_no_superlative_adjectives(message):
-    morph = pymorphy3.MorphAnalyzer()
-    words = message.split()
-    morphs = [morph.parse(word)[0] for word in words]
+def check_no_superlative_adjectives(message, exceptions=None):
+    """
+    Проверка на превосходную степень прилагательных.
+    Если lemma прилагательного среди exceptions['superlative_adjectives'], разрешаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("superlative_adjectives", set())
 
-    for morph in morphs:
-        if 'Supr' in morph.tag:
-            print(f"Не пройдена проверка: Превосходная степень прилагательных. Сообщение: {message}")
-            return False, f'Не пройдена проверка на превосходную степерь прилагательного: {morph.word}'
+    morph = pymorphy3.MorphAnalyzer()
+    for w in message.split():
+        p = morph.parse(w)[0]
+        lemma = p.normal_form
+        if 'Supr' in p.tag:
+            if lemma not in allowed_lemmas:
+                return False, f"Не пройдена проверка на превосходную степень: {p.word}"
     return True
 
 
 # 9. Страдательный залог
 
-def check_no_passive_voice(message):
+def check_no_passive_voice(message, exceptions=None):
+    """
+    Проверка на страдательный залог.
+    Если lemma в exceptions['passive_voice'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("passive_voice", set())
+
     morph = pymorphy3.MorphAnalyzer()
-    # Разбиваем сообщение на слова, игнорируя пунктуацию
     words = re.findall(r'\b\w+(?:-\w+)*\b', message.lower())
 
-    for word in words:
-        parse = morph.parse(word)[0]  # Берём только первый разбор
-        if 'pssv' in parse.tag:
-            return False, f'Не пройдена проверка на страдательный залог: {word}'
+    for w in words:
+        p = morph.parse(w)[0]
+        lemma = p.normal_form
+        if 'pssv' in p.tag:
+            if lemma not in allowed_lemmas:
+                return False, f"Не пройдена проверка на страдательный залог: {w}"
     return True
 
 
 # 10. Порядковые числительные от 10 прописью
 
-def check_no_written_out_ordinals(message):
+def check_no_written_out_ordinals(message, exceptions=None):
+    """
+    Проверка на порядковые числительные, написанные прописью (десятый и т.д.).
+    Если lemma в exceptions['written_out_ordinals'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("written_out_ordinals", set())
+
     morph = pymorphy3.MorphAnalyzer()
     ordinal_words = [
-        "десятый", "одиннадцатый", "двенадцатый", "тринадцатый", "четырнадцатый", "пятнадцатый",
-        "шестнадцатый", "семнадцатый", "восемнадцатый", "девятнадцатый", "двадцатый"
+        "десятый", "одиннадцатый", "двенадцатый", "тринадцатый",
+        "четырнадцатый", "пятнадцатый", "шестнадцатый", "семнадцатый",
+        "восемнадцатый", "девятнадцатый", "двадцатый"
     ]
-
-    words = message.split()
-    lemmas = [morph.parse(word)[0].normal_form for word in words]
-
-    for word in ordinal_words:
-        if word in lemmas:
-            print(f"Не пройдена проверка: Порядковые числительные от 10 прописью. Сообщение: {message}")
-            return False, f'Не пройдена проверка на порядковые числительные: {word}'
+    tokens = message.split()
+    lemmas = [morph.parse(t)[0].normal_form for t in tokens]
+    for ow in ordinal_words:
+        if ow in lemmas:
+            if ow not in allowed_lemmas:
+                return False, f"Не пройдена проверка на порядковые числительные: {ow}"
     return True
 
 
@@ -1196,99 +1307,152 @@ def check_no_subordinate_clauses_chain(message):
 
 # 12. Разделительные повторяющиеся союзы
 
-def check_no_repeating_conjunctions(message):
-    # Регулярное выражение для поиска разделительных повторяющихся союзов с запятой перед вторым союзом
-    repeating_conjunctions_patterns = r'\b(и|ни|то|не то|или|либо)\b\s*(.*?)\s*,\s*\b\1\b'
+def check_no_repeating_conjunctions(message, exceptions=None):
+    """
+    Проверка на повторяющиеся союзы 'и', 'или' и т.п.
+    Если сам союз (в лемме) в exceptions['repeating_conjunctions'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_conjs = exceptions.get("repeating_conjunctions", set())
 
-    # Разделяем сообщение на предложения по точке, вопросительному и восклицательному знакам
+    pattern = re.compile(r'\b(и|ни|то|не то|или|либо)\b\s*(.*?)\s*,\s*\b\1\b', re.IGNORECASE)
     sentences = re.split(r'[.!?]\s*', message)
-
-    # Проверяем каждое предложение отдельно
-    for sentence in sentences:
-        if re.search(repeating_conjunctions_patterns, sentence, re.IGNORECASE):
-            print(f"Не пройдена проверка: Разделительные повторяющиеся союзы. Сообщение: {message}")
-            return False, f'Не пройдена проверка на разделительные повторяющиеся союзы: {sentence}'
+    for s in sentences:
+        m = pattern.search(s)
+        if m:
+            conj = m.group(1).lower()
+            if conj not in allowed_conjs:
+                return False, f"Не пройдена проверка на повторяющиеся союзы: {s}"
     return True
 
 
 # 13. Вводные конструкции
 
-def check_no_introductory_phrases(message):
-    introductory_phrases = [
+def check_no_introductory_phrases(message, exceptions=None):
+    """
+    Проверка на вводные конструкции.
+    Если exact фраза в exceptions['introductory_phrases'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_phrases = exceptions.get("introductory_phrases", set())
+
+    patterns = [
         r'\b(во-первых|во-вторых|с одной стороны|по сути|по правде говоря)\b',
         r'\b(может быть|кстати|конечно|естественно|безусловно|возможно)\b'
     ]
-
-    for pattern in introductory_phrases:
-        if re.search(pattern, message, re.IGNORECASE):
-            print(f"Не пройдена проверка: Вводные конструкции. Сообщение: {message}")
-            return False, f'Не пройдена проверка на вводные конструкции: {pattern}'
+    for pat in patterns:
+        match = re.search(pat, message, re.IGNORECASE)
+        if match:
+            found = match.group(1).lower()
+            if found not in allowed_phrases:
+                return False, f"Не пройдена проверка на вводные конструкции: {found}"
     return True
 
 
 # 14. Усилители
 
-def check_no_amplifiers(message):
-    amplifiers = [
-        r'\b(очень|крайне|чрезвычайно|совсем|полностью|чисто)\b'
-    ]
+def check_no_amplifiers(message, exceptions=None):
+    """
+    Проверка на усилители (очень, крайне...).
+    Если лемма в exceptions['amplifiers'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("amplifiers", set())
 
-    for pattern in amplifiers:
-        if re.search(pattern, message, re.IGNORECASE):
-            print(f"Не пройдена проверка: Усилители. Сообщение: {message}")
-            return False, f"Не пройдена проверка на усилители: {pattern}"
+    pattern = re.compile(r'\b(очень|крайне|чрезвычайно|совсем|полностью|чисто)\b', re.IGNORECASE)
+    matches = pattern.findall(message)
+    if matches:
+        morph = pymorphy3.MorphAnalyzer()
+        for m in matches:
+            lemma, _ = lemmatize_word(m, morph)
+            if lemma not in allowed_lemmas:
+                return False, f"Не пройдена проверка на усилители: {m}"
     return True
 
 # 15. Паразиты времени
 
-def check_no_time_parasites(message):
-    time_parasites = [
-        r'\b(немедленно|срочно|в данный момент)\b'
-    ]
+def check_no_time_parasites(message, exceptions=None):
+    """
+    Проверка на «паразиты времени» (немедленно, срочно...).
+    Если лемма в exceptions['time_parasites'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("time_parasites", set())
 
-    for pattern in time_parasites:
-        if re.search(pattern, message, re.IGNORECASE):
-            print(f"Не пройдена проверка: Паразиты времени. Сообщение: {message}")
-            return False, f'Не пройдена проверка на паразитов времени: {pattern}'
+    pattern = re.compile(r'\b(немедленно|срочно|в данный момент)\b', re.IGNORECASE)
+    matches = pattern.findall(message)
+    if matches:
+        morph = pymorphy3.MorphAnalyzer()
+        for m in matches:
+            lemma, _ = lemmatize_word(m, morph)
+            if lemma not in allowed_lemmas:
+                return False, f"Не пройдена проверка на паразитов времени: {m}"
     return True
 
 
 # 16. Несколько существительных подряд
 
-def check_no_multiple_nouns(message):
-    noun_count = 0
-    words = re.split(r'\s+|[.!?]', message)  # Разбиваем по пробелам и знакам препинания
-    morph = pymorphy3.MorphAnalyzer()
+def check_no_multiple_nouns(message, exceptions=None):
+    """
+    Проверка на 3+ подряд существительных.
+    Если конкретная цепочка лемм в exceptions['multiple_nouns'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_chains = exceptions.get("multiple_nouns", set())  # set of tuples
 
-    for word in range(len(words)):
-        parsed_word = morph.parse(words[word])[0]
+    morph = pymorphy3.MorphAnalyzer()
+    tokens = re.split(r'\s+|[.!?]', message)
+    chain = []
+    count = 0
 
-        # Если слово — существительное
-        if 'NOUN' in parsed_word.tag:
-            noun_count += 1
-        # Если встречен конец предложения (точка, вопросительный знак, восклицательный знак)
-        elif re.match(r'[.!?]', words[word]):
-            noun_count = 0
+    for t in tokens:
+        t = t.strip()
+        if not t:
+            continue
+        p = morph.parse(t)[0]
+        lemma = p.normal_form
+        if 'NOUN' in p.tag:
+            count += 1
+            chain.append(lemma)
         else:
-            noun_count = 0
+            count = 0
+            chain = []
 
-        if noun_count > 2:
-            print(f"Не пройдена проверка: Несколько существительных подряд. Сообщение: {message}")
-            return False, f'Не пройдена проверка на несколько существительных подряд: {words[word - 2: word + 1]}'
+        if count > 2:
+            chain_tuple = tuple(chain)  # например ('зачисление', 'зарплата', 'сотрудникам')
+            if chain_tuple not in allowed_chains:
+                return False, f"Несколько существительных подряд: {chain_tuple}"
     return True
 
 
 # 17. Производные предлоги
 
-def check_no_derived_prepositions(message):
-    derived_prepositions = [
-        r'\b(в течение|в ходе|вследствие|в связи с|по мере|при помощи|согласно|вопреки|на основании|на случай|в продолжение|по причине|вблизи|вдалеке|вокруг|внутри|вдоль|посередине|вне|снаружи|благодаря|невзирая на|исходя из|благодаря)\b'
-    ]
-
-    for pattern in derived_prepositions:
-        if re.search(pattern, message, re.IGNORECASE):
-            print(f"Не пройдена проверка: Производные предлоги. Сообщение: {message}")
-            return False, f"Не пройдена проверка на производные предлоги: {pattern}"
+def check_no_derived_prepositions(message, exceptions=None):
+    """
+    Проверка на производные предлоги. 
+    Если конкретный предлог в exceptions['derived_prepositions'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_preps = exceptions.get("derived_prepositions", set())
+
+    pattern_text = (r'\b(в течение|в ходе|вследствие|в связи с|по мере|при помощи|'
+                    r'согласно|вопреки|на основании|на случай|в продолжение|по причине|'
+                    r'вблизи|вдалеке|вокруг|внутри|вдоль|посередине|вне|снаружи|'
+                    r'благодаря|невзирая на|исходя из|благодаря)\b')
+    pat = re.compile(pattern_text, re.IGNORECASE)
+
+    matches = pat.findall(message)
+    if matches:
+        for m in matches:
+            low = m.lower()
+            if low not in allowed_preps:
+                return False, f"Не пройдена проверка на производные предлоги: {m}"
     return True
 
 
@@ -1312,84 +1476,78 @@ def check_no_compound_sentences(message):
 
 # 20. Даты прописью
 
-def check_no_dates_written_out(message):
-    # Ищем упоминания месяцев или слов, связанных с датами
+def check_no_dates_written_out(message, exceptions=None):
+    """
+    Проверка на даты прописью.
+    Если (lemma_ordinal, lemma_month) в exceptions['dates_written_out'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_dates = exceptions.get("dates_written_out", set())
+
+    morph = pymorphy3.MorphAnalyzer()
+
     months = [
         "января", "февраля", "марта", "апреля", "мая", "июня",
         "июля", "августа", "сентября", "октября", "ноября", "декабря"
     ]
-
-    # Слова для проверки чисел прописью
-    date_written_out_patterns = [
-        r'\b(первого|второго|третьего|четвертого|пятого|шестого|седьмого|восьмого|девятого|десятого|одиннадцатого|двенадцатого|тринадцатого|четырнадцатого|пятнадцатого|шестнадцатого|семнадцатого|восемнадцатого|девятнадцатого|двадцатого|двадцать первого|двадцать второго|двадцать третьего|двадцать четвертого|двадцать пятого|двадцать шестого|двадцать седьмого|двадцать восьмого|двадцать девятого|тридцатого|тридцать первого)\b'
+    date_patterns = [
+        r'\b(первого|второго|третьего|четвертого|пятого|шестого|седьмого|'
+        r'восьмого|девятого|десятого|одиннадцатого|двенадцатого|'
+        r'тринадцатого|четырнадцатого|пятнадцатого|шестнадцатого|'
+        r'семнадцатого|восемнадцатого|девятнадцатого|двадцатого|'
+        r'двадцать первого|двадцать второго|двадцать третьего|'
+        r'двадцать четвертого|двадцать пятого|двадцать шестого|'
+        r'двадцать седьмого|двадцать восьмого|двадцать девятого|'
+        r'тридцатого|тридцать первого)\b'
     ]
 
-    for month in months:
-        for pattern in date_written_out_patterns:
-            if re.search(f'{pattern}\\s{month}', message, re.IGNORECASE):
-                print(f"Не пройдена проверка: Даты прописью. Сообщение: {message}")
-                return False, f"Не пройдена проверка на даты прописью: {pattern}"
-
+    for m in months:
+        for patt in date_patterns:
+            found = re.search(f"{patt}\\s{m}", message, re.IGNORECASE)
+            if found:
+                ordinal_str = found.group(1).lower()  # например «пятнадцатого»
+                lemma_ord, _ = lemmatize_word(ordinal_str, morph)
+                lemma_month, _ = lemmatize_word(m, morph)
+                pair = (lemma_ord, lemma_month)  # («пятнадцатый», «июль»)
+                if pair not in allowed_dates:
+                    return False, f"Не пройдена проверка на даты прописью: {found.group(0)}"
     return True
 
 # Доп правило. Повторы слов
 
-def check_no_word_repetitions(message, key_message):
-    morph = pymorphy3.MorphAnalyzer()
-
-    # Определяем набор частей речи, которые будем игнорировать
-    ignore_pos = {
-        'PREP',  # Предлоги
-        'CONJ',  # Союзы
-        'PRON',  # Местоимения
-        'INTJ',  # Междометия
-        'NUMR',  # Числительные
-        'PART',  # Частицы
-        'NPRO'
-    }
+def check_no_word_repetitions(message, key_message, exceptions=None):
+    """
+    Проверка на повторы слов (кроме определённых частей речи).
+    Если lemma есть в exceptions['word_repetitions'], пропускаем.
+    """
+    if exceptions is None:
+        exceptions = {}
+    allowed_lemmas = exceptions.get("word_repetitions", set())
 
-    # Разбиваем текст на слова, учитывая составные слова с дефисом
-    words = re.findall(r'\b\w+(?:-\w+)*\b', message.lower())
+    morph = pymorphy3.MorphAnalyzer()
+    ignore_pos = {'PREP', 'CONJ', 'PRON', 'INTJ', 'NUMR', 'PART', 'NPRO'}
 
-    # Функция для нормализации слов и получения их базовых форм
-    def normalize_word(word):
-        parses = morph.parse(word)
-        if not parses:
-            return word  # Если слово не распознано, возвращаем как есть
-        parse = parses[0]
-        return parse.normal_form, parse.tag.POS
+    msg_words = re.findall(r'\b\w+(?:-\w+)*\b', message.lower())
 
-    # Нормализуем ключевое сообщение и собираем его базовые формы
+    # Ключевое сообщение
     key_normalized = set()
-    for word in re.findall(r'\b\w+\b', key_message.lower()):
-        norm, pos = normalize_word(word)
-        key_normalized.add(norm)
-
-    # Добавляем базовые формы ключевого сообщения в игнорируемые слова
-    # Это позволяет игнорировать повторения слов из ключевого сообщения
-    # Кроме того, игнорируем слова из определенных частей речи
-    normalized_words = {}
-
-    for word in words:
-        norm, pos = normalize_word(word)
-
-        # Игнорируем слово, если оно относится к одной из игнорируемых частей речи
-        if pos in ignore_pos:
+    for kw in re.findall(r'\b\w+\b', key_message.lower()):
+        lemma_k, pos_k = lemmatize_word(kw, morph)
+        key_normalized.add(lemma_k)
+
+    seen = {}
+    for w in msg_words:
+        lemma, pos = lemmatize_word(w, morph)
+        if (not pos) or (pos in ignore_pos):
             continue
-
-        # Игнорируем слово, если оно присутствует в ключевом сообщении
-        if norm in key_normalized:
+        if lemma in key_normalized:
             continue
-
-        # Если слово уже встречалось, возвращаем False
-        if norm in normalized_words:
-            print(f"Не пройдена проверка: Повторы слов. Сообщение: {message}")
-            return False, f"Не пройдена проверка на повторы слов: {norm}"
-
-        # Добавляем слово в словарь для отслеживания повторов
-        normalized_words[norm] = True
-
-    # Если повторов не найдено, возвращаем True
+        if lemma in allowed_lemmas:
+            continue
+        if lemma in seen:
+            return False, f"Не пройдена проверка на повторы слов: {lemma}"
+        seen[lemma] = True
     return True
 
 # ФУНКЦИИ ПРОВЕРОК (КОНЕЦ)