Update app.py

app.py

@@ -558,6 +558,7 @@ final_prompt_2_state = gr.State("")
 def generate_personalized_sms_wrapper(selected_product, description, product_name, benefits, key_message,
                                       gender, generation, psychotype, business_stage, industry, opf,
                                       chosen_approach, prompt_1, prompt_2):
+    source_report, exceptions_dict = check_source_fields(description, product_name, benefits, key_message)
     if "Для формирования промпта выберите хотя бы один личный персональный параметр" in prompt_1 or chosen_approach == "Подход не найден для выбранных параметров.":
         gr.Warning("Задайте хотя бы один личный персональный параметр для определения подхода")
         return "", "", "", ""
@@ -576,12 +577,12 @@ def generate_personalized_sms_wrapper(selected_product, description, product_nam
 
     # Выполняем проверки sms_1
     cut_sms_1 = cut_message(sms_1)
-    checks_1 = perform_checks(cut_sms_1, key_message)
+    checks_1 = perform_checks(cut_sms_1, key_message, exceptions_dict)
     checks_formatted_1 = format_checks(checks_1)
 
     # Выполняем проверки sms_2
     cut_sms_2 = cut_message(sms_2)
-    checks_2 = perform_checks(cut_sms_2, key_message)
+    checks_2 = perform_checks(cut_sms_2, key_message, exceptions_dict)
     checks_formatted_2 = format_checks(checks_2)
     
     personalization_params = [gender, generation, psychotype, business_stage, industry, opf]
@@ -1107,6 +1108,17 @@ def extract_failed_checks(checks_dict, exceptions_dict, context=""):
                         w = match.group(1).lower()
                         exceptions_dict.setdefault("derived_prepositions", set()).add(w)
 
+                elif rule_key == "compound_sentences":
+                    # reason может выглядеть так:
+                    # "Не пройдена проверка: Сложноподчиненные предложения: как только"
+                    # Разделим по двоеточию:
+                    splitted = reason.split(': ', 2)
+                    # splitted может быть ["Не пройдена проверка", "Сложноподчиненные предложения", "как только"]
+                    if len(splitted) == 3:
+                        raw_substring = splitted[2].strip()
+                        # Добавляем сырую подстроку (без лемматизации) в исключения
+                        exceptions_dict["compound_sentences"].add(raw_substring)
+
                 elif rule_key == "dates_written_out":
                     # reason: "Не пройдена проверка на даты прописью: пятнадцатого июля"
                     match = re.search(r'даты прописью:\s*(.+)$', reason)
@@ -1601,7 +1613,17 @@ def check_no_derived_prepositions(message, exceptions=None):
 
 # 19. Сложноподчиненные предложения
 
-def check_no_compound_sentences(message):
+def check_no_compound_sentences(message, exceptions=None):
+    """
+    Проверка на отсутствие сложноподчиненных предложений.
+    Если обнаружен союз/слово, которое есть в exceptions["compound_sentences"], 
+    — НЕ считаем ошибкой.
+    Если нет в исключениях, считаем ошибкой.
+    """
+    if exceptions is None:
+        exceptions = {}
+
+    # Список союзов/фраз, по которым мы определяем сложноподчинённость
     subordinating_conjunctions = [
         r'\bкогда\b', r'\bкак только\b', r'\bпока\b', r'\bпосле того как\b',
         r'\bпотому что\b', r'\bтак как\b', r'\bоттого что\b', r'\bблагодаря тому что\b',
@@ -1609,11 +1631,19 @@ def check_no_compound_sentences(message):
         r'\bхотя\b', r'\bнесмотря на то что\b', r'\bкак\b', r'\bбудто\b', r'\bсловно\b', r'\bкак будто\b'
     ]
 
-    # Убедимся, что слово "как" используется не в вопросе
+    # Собираем «разрешённые» фразы (из исключений) – это сырые строки:
+    allowed_raw_phrases = exceptions.get("compound_sentences", set())
+
     for pattern in subordinating_conjunctions:
-        if re.search(pattern, message) and not re.search(r'\?', message):
-            print(f"Не пройдена проверка: Сложноподчиненные предложения. Сообщение: {message}")
-            return False, f"Не пройдена проверка: Сложноподчиненные предложения: {pattern}"
+        # Находим все вхождения союз��в
+        matches = re.finditer(pattern, message, re.IGNORECASE)
+        for m in matches:
+            raw_substring = m.group(0)  # «сырая» найденная строка
+            # Если substring НЕ в наших исключениях:
+            # (сравниваем без учёта регистра — можно .lower() )
+            if raw_substring.lower() not in (s.lower() for s in allowed_raw_phrases):
+                return (False, f'Не пройдена проверка: Сложноподчиненные предложения: {raw_substring}')
+
     return True
 
 
@@ -1714,30 +1744,40 @@ def safe_check(func, message, key_message=None):
         traceback.print_exc()  # выведет traceback
         return None
 
-def perform_checks(message, key_message):
+def perform_checks(message, key_message, exceptions_dict=None):
+    """
+    Запускает все проверки для данного message. 
+    exceptions_dict - словарь исключений:
+        {
+           "compound_sentences": set(...),
+           "double_verbs": set(...),
+           ...
+        }
+    и т.д.
+    """
     checks = {
-        "forbidden_words": safe_check(check_forbidden_words, message),
-        "client_addressing": safe_check(check_no_greeting, message),
-        "promises": safe_check(check_no_promises, message),
-        "double_verbs": safe_check(check_no_double_verbs, message),
-        "participles": safe_check(check_no_participles, message),
-        "adverbial_participles": safe_check(check_no_adverbial_participles, message),
-        "superlative_adjectives": safe_check(check_no_superlative_adjectives, message),
-        "passive_voice": safe_check(check_no_passive_voice, message),
-        "written_out_ordinals": safe_check(check_no_written_out_ordinals, message),
+        "forbidden_words": safe_check(lambda msg, km: check_forbidden_words(msg, exceptions_dict), message),
+        "client_addressing": safe_check(lambda msg, km: check_no_greeting(msg, exceptions_dict), message),
+        "promises": safe_check(lambda msg, km: check_no_promises(msg, exceptions_dict), message),
+        "double_verbs": safe_check(lambda msg, km: check_no_double_verbs(msg, exceptions_dict), message),
+        "participles": safe_check(lambda msg, km: check_no_participles(msg, exceptions_dict), message),
+        "adverbial_participles": safe_check(lambda msg, km: check_no_adverbial_participles(msg, exceptions_dict), message),
+        "superlative_adjectives": safe_check(lambda msg, km: check_no_superlative_adjectives(msg, exceptions_dict), message),
+        "passive_voice": safe_check(lambda msg, km: check_no_passive_voice(msg, exceptions_dict), message),
+        "written_out_ordinals": safe_check(lambda msg, km: check_no_written_out_ordinals(msg, exceptions_dict), message),
         "subordinate_clauses_chain": safe_check(check_no_subordinate_clauses_chain, message),
-        "repeating_conjunctions": safe_check(check_no_repeating_conjunctions, message),
-        "introductory_phrases": safe_check(check_no_introductory_phrases, message),
-        "amplifiers": safe_check(check_no_amplifiers, message),
-        "time_parasites": safe_check(check_no_time_parasites, message),
-        "multiple_nouns": safe_check(check_no_multiple_nouns, message),
-        "derived_prepositions": safe_check(check_no_derived_prepositions, message),
-        "compound_sentences": safe_check(check_no_compound_sentences, message),
-        "dates_written_out": safe_check(check_no_dates_written_out, message),
-        "no_word_repetitions": safe_check(check_no_word_repetitions, message, key_message),
+        "repeating_conjunctions": safe_check(lambda msg, km: check_no_repeating_conjunctions(msg, exceptions_dict), message),
+        "introductory_phrases": safe_check(lambda msg, km: check_no_introductory_phrases(msg, exceptions_dict), message),
+        "amplifiers": safe_check(lambda msg, km: check_no_amplifiers(msg, exceptions_dict), message),
+        "time_parasites": safe_check(lambda msg, km: check_no_time_parasites(msg, exceptions_dict), message),
+        "multiple_nouns": safe_check(lambda msg, km: check_no_multiple_nouns(msg, exceptions_dict), message),
+        "derived_prepositions": safe_check(lambda msg, km: check_no_derived_prepositions(msg, exceptions_dict), message),
+        "compound_sentences": safe_check(lambda msg, km: check_no_compound_sentences(msg, exceptions_dict), message),
+        "dates_written_out": safe_check(lambda msg, km: check_no_dates_written_out(msg, exceptions_dict), message),
+        "no_word_repetitions": safe_check(lambda msg, km: check_no_word_repetitions(msg, km, exceptions_dict), message, key_message),
     }
     return checks
-
+    
 def format_checks(checks):
     
     translation = {