Update app.py

app.py

@@ -13,297 +13,267 @@ GEMINI_API_KEY = "AIzaSyBoqoPX-9uzvXyxzse0gRwH8_P9xO6O3Bc"
 if not GEMINI_API_KEY:
     print("Error: GEMINI_API_KEY is not set.")
     exit()
-
 genai.configure(api_key=GEMINI_API_KEY)
 
+# Доступные модели
 AVAILABLE_MODELS = [
     "gemini-1.5-flash",
     "gemini-1.5-pro",
-    "gemini-2.0-flash-thinking-exp"
+    "gemini-2.0-flash-thinking-exp",
 ]
 
-# Создаём объекты-модели и храним их в словаре для быстрого доступа
+# Пытаемся инициализировать все модели заранее и складываем в словарь
 MODELS = {}
 for model_name in AVAILABLE_MODELS:
     try:
         MODELS[model_name] = genai.GenerativeModel(model_name=model_name)
     except Exception as e:
-        print(f"Не удалось инициализировать модель {model_name}: {e}")
+        print(f"[Предупреждение] Не удалось инициализировать модель {model_name}: {e}")
+
 
 ###############################################################################
-# 2. Функции для генерации ответов
+# 2. Утилиты для преобразования истории Gradio <-> Gemini
 ###############################################################################
 
-def _convert_history_to_genai_format(history):
+def _history_gradio_to_genai(history):
     """
-    Gradio-хранит чат как список кортежей: [(user_msg, bot_msg), (user_msg, bot_msg), ...]
-    Для Gemini же нужна история вида [{'role': 'user', 'content': ...}, {'role': 'assistant', 'content': ...}, ...].
-
-    Возвращает список dict, где role = user/assistant, content = текст.
+    Gradio хранит чат как [(user_msg, bot_msg), (user_msg, bot_msg), ...].
+    Для Gemini нужен формат [{'role': 'user', 'content': ...}, ...].
     """
     genai_history = []
     for user_text, bot_text in history:
-        if user_text:  # сообщение от пользователя
+        if user_text:
             genai_history.append({"role": "user", "content": user_text})
-        if bot_text:   # сообщение от ассистента
+        if bot_text:
             genai_history.append({"role": "assistant", "content": bot_text})
     return genai_history
 
 
-def _convert_genai_to_chatbot_format(history):
-    """
-    Обратное преобразование:
-    [{'role': 'user', 'content': ...}, {'role': 'assistant', 'content': ...}]
-    -> [(user_msg, bot_msg), ...]
-    
-    Упрощённо полагаем, что роли будут идти поочерёдно user-assistant.
-    Если вдруг несколько подряд от одного и того же role, объединяем по очереди.
-    """
-    display_history = []
-    user_buffer = None
-
-    for turn in history:
-        role = turn["role"]
-        content = turn["content"]
-        if role == "user":
-            # Запускаем новую пару
-            user_buffer = content
-        elif role == "assistant":
-            if user_buffer is not None:
-                display_history.append((user_buffer, content))
-                user_buffer = None
-            else:
-                # На случай, если идёт assistant без user
-                display_history.append((None, content))
-
-    # Если вдруг остался user_buffer без ответа (редко бывает)
-    if user_buffer is not None:
-        display_history.append((user_buffer, None))
-
-    return display_history
-
+###############################################################################
+# 3. Функции-генераторы для запроса ответа от моделей (обычный/thinking)
+###############################################################################
 
 async def _respond_stream(model_name, user_message, history):
     """
-    Генерация ОТВЕТА С ПОСТЕПЕННЫМ стримингом (для моделей без "thinking").
-    Возвращает генератор, чтобы Gradio мог пошагово обновлять вывод.
+    Генерация ответа для Обычных моделей (без thinking) с помощью stream=True
+    - Возвращаем куски текста через yield
+    - В конце просто делаем return (без значения)
     """
     if model_name not in MODELS:
         yield "Ошибка: модель не найдена."
         return
 
     model = MODELS[model_name]
-    genai_history = _convert_history_to_genai_format(history)
-    
+    genai_history = _history_gradio_to_genai(history)
+
     try:
         chat = model.start_chat(history=genai_history)
-        # Запрашиваем стриминг-ответ
         response_stream = chat.send_message(user_message, stream=True)
 
         partial_text = ""
         for chunk in response_stream:
             chunk_text = chunk.text or ""
             partial_text += chunk_text
-            # Возвращаем накопленный ответ
+            # Возвращаем промежуточный вариант ответа
             yield partial_text
+
+        return  # Завершить генератор без возвращения значения
     except Exception as e:
-        yield f"Error during API call: {e}"
+        yield f"Ошибка при запросе к API: {e}"
+        return
 
 
 async def _respond_thinking(model_name, user_message, history):
     """
-    Генерация ответа для моделей с "thinking" (gemini-2.0-flash-thinking-exp).
-    1) Выдаём "Думаю..."
-    2) По завершении запроса возвращаем итоговый ответ
-    3) При желании можно вернуть размышления в отдельную переменную
+    Генерация ответа для модели с "thinking" (например, gemini-2.0-flash-thinking-exp).
+    1) Сначала выдаём "Думаю..."
+    2) Затем, когда модель ответит (stream=False), выделяем thinking + финальный ответ.
+    3) Возвращаем (полезный_ответ, размышления) в виде кортежа.
+       В Gradio это обычно [(assistant_text, thinking_text), ...].
     """
     if model_name not in MODELS:
-        return "Ошибка: модель не найдена.", ""
+        # Выдаем ошибку через yield
+        yield "Ошибка: модель не найдена.", ""
+        return
 
     model = MODELS[model_name]
-    genai_history = _convert_history_to_genai_format(history)
+    genai_history = _history_gradio_to_genai(history)
 
-    # 1) "Думаю..."
-    yield "Думаю...", ""  # (ответ в чат, размышления)
+    # Шаг 1: временно "Думаю..."
+    yield "Думаю...", ""
 
     try:
         chat = model.start_chat(history=genai_history)
-        response = chat.send_message(user_message, stream=False)  # без stream
+        response = chat.send_message(user_message, stream=False)
 
-        # Для thinking-моделей ответ приходит в виде parts
         thinking_process_text = ""
         final_text = ""
         if response.candidates:
-            for part in response.candidates[0].content.parts:
-                # Если в part есть .thought == True, считаем это «размышлениями»
-                if getattr(part, "thought", False):
-                    thinking_process_text += part.text or ""
+            parts = response.candidates[0].content.parts
+            for p in parts:
+                if getattr(p, "thought", False):
+                    thinking_process_text += p.text or ""
                 else:
-                    final_text += part.text or ""
+                    final_text += p.text or ""
 
-        # Возвращаем итоговый ответ
+        # Возвращаем готовый ответ и размышления
         yield final_text, thinking_process_text
-
+        return
     except Exception as e:
-        yield f"Error during API call: {e}", f"Error: {e}"
+        yield f"Ошибка при запросе к API: {e}", ""
+        return
 
 
 ###############################################################################
-# 3. Основная функция (колбэк для Gradio), обрабатывающая один «шаг» диалога
+# 4. Основная асинхронная функция Gradio, обрабатывающая новый пользовательский ввод
 ###############################################################################
 
-async def user_send_message(user_message, history, model_name, thinking_store):
+async def user_send_message(
+    user_message: str,
+    history: list[tuple[str, str]],
+    model_name: str,
+    thinking_text: str
+):
     """
-    Эта функция вызывается при нажатии кнопки "Отправить" (или Enter).
     Параметры:
-      user_message: текст от пользователя
-      history:    текущее состояние чата [(user_msg, bot_msg), ...]
+      user_message: вход от пользователя (текущая реплика)
+      history: история [(user, assistant), ...]
       model_name: выбранная модель
-      thinking_store: текущее значение поля "Размышления"
+      thinking_text: текущее содержимое поля «Размышления»
 
-    Возвращаем:
-      (updated_history, updated_thinking_store)
+    Выход (через yield):
+      (обновлённая история, обновлённое thinking_text)
     """
+    # Если пользователь ничего не ввёл, просто возвращаем текущее состояние
     if not user_message.strip():
-        # Пустая строка – ничего не делаем
-        return history, thinking_store
+        yield history, thinking_text
+        return
 
-    # Добавляем в историю шаг пользователя
-    history.append((user_message, None))  # Пока ассистента нет
+    # Добавляем новую запись в историю: ассистент пока None
+    history.append((user_message, None))
 
-    # Если модель thinking
+    # Проверяем, thinking-модель ли
     if "thinking" in model_name.lower():
-        # Асинхронный генератор: сначала "Думаю...", потом финальный ответ
-        async for (assistant_text, thinking_text) in _respond_thinking(model_name, user_message, history):
-            # Обновляем последний элемент истории (None -> assistant_text)
+        # Обрабатываем через _respond_thinking
+        async for (assistant_text, thought_text) in _respond_thinking(model_name, user_message, history):
+            # Обновляем последнюю пару в истории
             history[-1] = (user_message, assistant_text)
-            # Обновляем thinking_output
-            yield history, thinking_text
+            # Обновляем thinking_text
+            yield history, thought_text
+        return
     else:
-        # Стриминговый ответ
+        # Обычная модель (stream)
         partial_answer = ""
-        async for partial_chunk in _respond_stream(model_name, user_message, history):
-            partial_answer = partial_chunk
+        async for chunk in _respond_stream(model_name, user_message, history):
+            partial_answer = chunk
             history[-1] = (user_message, partial_answer)
-            # В режиме без thinking просто очищаем thinking_store
+            # В обычном режиме thinking_text = ""
             yield history, ""
-
-    # Когда генерация закончена, возвращаем итог
-    return history, thinking_store
+        return
 
 
 ###############################################################################
-# 4. Колбэки для кнопки "Очистить"
+# 5. Колбэки для очистки
 ###############################################################################
 
 def clear_all():
     """
-    Полная очистка истории чата и поля «Размышления».
-    Возвращает пустые значения для State и компонентов.
+    Полная очистка чата и размышлений.
     """
-    return [], ""  # history, thinking_store
+    return [], ""  # (history, thinking_store)
 
 
 ###############################################################################
-# 5. Определяем Gradio-интерфейс
+# 6. Определяем интерфейс Gradio
 ###############################################################################
 
 with gr.Blocks() as demo:
-    gr.Markdown("## Gemini Chatbot с сохранением истории и «thinking»-режимом")
-
-    # Храним историю диалога (список кортежей) в gr.State
-    history_state = gr.State([])
-
-    # Храним «размышления» (thinking) в отдельном тексте
-    thinking_store = gr.State("")
+    gr.Markdown("## Gemini Chatbot (с сохранением истории и thinking-режимом)")
 
     with gr.Row():
         model_dropdown = gr.Dropdown(
             choices=AVAILABLE_MODELS,
             value="gemini-1.5-flash",
-            label="Выберите модель"
+            label="Выберите модель",
         )
         clear_button = gr.Button("Очистить чат")
 
-    # Сам чат: компонент Chatbot для отображения диалога
+    # Храним историю чата в gr.State
+    history_state = gr.State([])  # список кортежей (user, assistant)
+    # Храним «размышления» отдельно
+    thinking_store = gr.State("")
+
     chatbot = gr.Chatbot(label="Диалог с Gemini")
 
-    # Поле ввода сообщения
     user_input = gr.Textbox(
-        label="Ваш вопрос/сообщение",
-        placeholder="Введите вопрос...",
+        label="Ваш вопрос",
+        placeholder="Введите вопрос и нажмите Enter...",
     )
 
-    # Поле для показа «Размышлений» (если модель thinking)
+    # Отдельный блок для показа «размышлений»
     thinking_output = gr.Textbox(
-        label="Размышления модели (только для gemini-2.0-flash-thinking-exp)",
+        label="Размышления (только для gemini-2.0-flash-thinking-exp)",
         interactive=False
     )
 
-    # Кнопка «Отправить»
     send_btn = gr.Button("Отправить")
 
-    ############################################################################
-    # Связываем действия пользователя с колбэками
-    ############################################################################
-    # 1. При нажатии «Отправить» запускаем user_send_message
-    #    - обновляем историю и thinking_output
-    #    - одновременно обновляем отображение чата
+    # Связка: кнопка «Отправить» => user_send_message => обновление истории и размышлений
     send_btn.click(
         fn=user_send_message,
         inputs=[user_input, history_state, model_dropdown, thinking_store],
         outputs=[history_state, thinking_store],
-        queue=True,
+        queue=True
     ).then(
-        # После обновления history_state, пересчитываем отображение чата
+        # После того как получили новую историю, обновляем чат
         fn=lambda h: h,
         inputs=[history_state],
         outputs=[chatbot],
-        preprocess=False,
-        postprocess=True
+        queue=True
     ).then(
-        # После этого выводим текущее состояние thinking_store
+        # После этого выводим thinking_store
         fn=lambda t: t,
         inputs=[thinking_store],
         outputs=[thinking_output],
+        queue=True
     )
 
-    # 2. При нажатии Enter в текстовом поле — та же логика, что и на кнопке
+    # Аналогичное поведение при нажатии Enter в поле ввода
     user_input.submit(
         fn=user_send_message,
         inputs=[user_input, history_state, model_dropdown, thinking_store],
         outputs=[history_state, thinking_store],
-        queue=True,
+        queue=True
     ).then(
         fn=lambda h: h,
         inputs=[history_state],
         outputs=[chatbot],
-        preprocess=False,
-        postprocess=True
+        queue=True
     ).then(
         fn=lambda t: t,
         inputs=[thinking_store],
         outputs=[thinking_output],
+        queue=True
     )
 
-    # 3. Кнопка «Очистить»
+    # Кнопка «Очистить» сбрасывает историю и thinking_store
     clear_button.click(
         fn=clear_all,
         inputs=[],
         outputs=[history_state, thinking_store],
         queue=False
     ).then(
+        # Затем обновляем чат
         fn=lambda h: h,
         inputs=[history_state],
-        outputs=chatbot,
+        outputs=[chatbot]
     ).then(
+        # И обнуляем thinking_output
         fn=lambda _: "",
         inputs=[],
-        outputs=thinking_output
+        outputs=[thinking_output]
     )
 
-###############################################################################
-# 6. Запуск
-###############################################################################
+# Запуск Gradio
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()