Update app.py

app.py

@@ -968,8 +968,14 @@ def on_check_source_fields(description, product_name, benefits, key_message):
     return check_source_fields(description, product_name, benefits, key_message)
 
 
-def extract_failed_checks(checks_dict):
-
+def extract_failed_checks(checks_dict, exceptions_dict, context=""):
+    """
+    Пробегаемся по результатам checks_dict.
+    Если есть (False, reason), выводим reason, 
+    и при необходимости парсим reason, чтобы добавить исключения в exceptions_dict.
+    """
+    import re
+    import pymorphy3
     morph = pymorphy3.MorphAnalyzer()
 
     lines = []
@@ -980,15 +986,152 @@ def extract_failed_checks(checks_dict):
         return (p1, p2)
 
     for rule_key, result in checks_dict.items():
-        # Определяем, было ли нарушение
         if isinstance(result, tuple):
             passed, reason = result
-            if not passed:  # passed == False
-                # например: "Запрещенные слова: успех"
+            if not passed:
                 lines.append(f"{rule_to_str(rule_key)}: {reason}")
+                # Пример: если rule_key == "double_verbs"
+                if rule_key == "double_verbs":
+                    # Ищем "...: 2 глагола подряд: позволяет зачислять"
+                    # Допустим reason = "Не пройдена проверка на 2 глагола подряд: позволяет зачислять"
+                    match = re.search(r'2 глагола подряд:\s*(\S+)\s+(\S+)$', reason)
+                    if match:
+                        w1 = match.group(1)
+                        w2 = match.group(2)
+                        pair_lemma = lemma_pair(w1, w2)
+                        exceptions_dict.setdefault("double_verbs", set()).add(pair_lemma)
+
+                elif rule_key == "forbidden_words":
+                    # reason вроде: "Запрещенное слово: продукт"
+                    match = re.search(r'Запрещенное слово:\s*(\S+)', reason)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("forbidden_words", set()).add(l)
+
+                elif rule_key == "client_addressing":
+                    # reason вроде: "Есть приветствие: дорогая"
+                    match = re.search(r'приветствие:\s*(\S+)', reason, re.IGNORECASE)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("greetings", set()).add(l)
+
+                elif rule_key == "promises":
+                    # reason напр. "Не пройдена проверка: обещания => обещать"
+                    match = re.search(r'=>\s*(\S+)$', reason)
+                    if match:
+                        patt = match.group(1)
+                        exceptions_dict.setdefault("promises", set()).add(patt)
+
+                elif rule_key == "participles":
+                    # reason "Не пройдена проверка на причастие: повышающий"
+                    match = re.search(r'причастие:\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("participles", set()).add(l)
+
+                elif rule_key == "adverbial_participles":
+                    # reason: "деепричастие => рассматривая"
+                    match = re.search(r'деепричастие\s*=>\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("adverbial_participles", set()).add(l)
+
+                elif rule_key == "superlative_adjectives":
+                    # reason: "Не пройдена проверка на превосходную степень: сильнейший"
+                    match = re.search(r'превосходную степень:\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("superlative_adjectives", set()).add(l)
+
+                elif rule_key == "passive_voice":
+                    # reason: "Страдательный залог: построен"
+                    match = re.search(r'страдательный залог:\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("passive_voice", set()).add(l)
+
+                elif rule_key == "written_out_ordinals":
+                    # reason: "Порядковые числительные: десятый"
+                    match = re.search(r'порядковые числительные:\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1)
+                        exceptions_dict.setdefault("written_out_ordinals", set()).add(w)
+
+                elif rule_key == "repeating_conjunctions":
+                    # reason: "Повторяющиеся союзы: ...", 
+                    match = re.search(r'союзы:\s*(\S+)', reason)
+
+                elif rule_key == "introductory_phrases":
+                    match = re.search(r'конструкции:\s*(\S+)$', reason)
+                    if match:
+                        phrase = match.group(1).lower()
+                        exceptions_dict.setdefault("introductory_phrases", set()).add(phrase)
+
+                elif rule_key == "amplifiers":
+                    # reason: "Не пройдена проверка на усилители: очень"
+                    match = re.search(r'усилители:\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("amplifiers", set()).add(l)
+
+                elif rule_key == "time_parasites":
+                    # reason: "Не пройдена проверка на паразитов времени: срочно"
+                    match = re.search(r'времени:\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1)
+                        l, _ = lemmatize_word(w, morph)
+                        exceptions_dict.setdefault("time_parasites", set()).add(l)
+
+                elif rule_key == "multiple_nouns":
+                    # reason: "Несколько существительных подряд: ('зачисление','зарплата','сотрудникам')"
+                    match = re.search(r'подряд:\s*(\([^)]+\))', reason)
+                    if match:
+                        chain_str = match.group(1)  # "('зачисление','зарплата','сотрудникам')"
+                        try:
+                            chain_tuple = eval(chain_str)
+                            exceptions_dict.setdefault("multiple_nouns", set()).add(chain_tuple)
+                        except:
+                            pass
+
+                elif rule_key == "derived_prepositions":
+                    # reason: "Не пройдена проверка на производные предлоги: благодаря"
+                    match = re.search(r'предлоги:\s*(\S+)$', reason)
+                    if match:
+                        w = match.group(1).lower()
+                        exceptions_dict.setdefault("derived_prepositions", set()).add(w)
+
+                elif rule_key == "dates_written_out":
+                    # reason: "Не пройдена проверка на даты прописью: пятнадцатого июля"
+                    match = re.search(r'даты прописью:\s*(.+)$', reason)
+                    if match:
+                        full = match.group(1).strip()
+                        splitted = full.split()
+                        if len(splitted) == 2:
+                            ord_str, month_str = splitted
+                            l_o, _ = lemmatize_word(ord_str, morph)
+                            l_m, _ = lemmatize_word(month_str, morph)
+                            pair = (l_o, l_m)
+                            exceptions_dict.setdefault("dates_written_out", set()).add(pair)
+
+                elif rule_key == "no_word_repetitions":  
+                    # reason: "Не пройдена проверка на повторы слов: зачисление"
+                    match = re.search(r'повторы слов:\s*(\S+)', reason, re.IGNORECASE)
+                    if match:
+                        rep_w = match.group(1)
+                        l, _ = lemmatize_word(rep_w, morph)
+                        exceptions_dict.setdefault("word_repetitions", set()).add(l)
+
         elif result is False:
-            # Если функция вернула просто False без пояснения
+            # Нет причины
             lines.append(f"{rule_to_str(rule_key)}: (без пояснения)")
+
     return "\n".join(lines)