Update app.py

app.py

@@ -1,9 +1,20 @@
+import asyncio
+import sys
+
+if sys.platform.startswith('win'):
+    # Используем более стабильную политику событий для Windows
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+    
+# Создаем новый цикл событий
+loop = asyncio.new_event_loop()
+asyncio.set_event_loop(loop)
+
 import g4f
 import gradio as gr
 import tempfile
 import os
 from pathlib import Path
-from g4f.client import Client
+from g4f.client import Client, AsyncClient
 from PIL import Image
 import io
 import requests
@@ -13,21 +24,32 @@ import subprocess
 import sys
 import time
 from typing import Dict, Any, Optional
+import easyocr
+import asyncio
 
 AVAILABLE_MODELS = {
     "GPT-4": "gpt-4",
     "GPT-4 Turbo": "gpt-4-turbo",
     "GPT-4o": "gpt-4o",
+    "GPT-4o THINK": "gpt-4o-think"
 }
  
 SYSTEM_PROMPT = """
 1. Всегда используйте кодировку UTF-8
 2. Используйте обработку ошибок
-3. Если пользователь просит нарисовать или сгенерировать изображение:
+3. Если пользователь отправляет изображение или пишет чтото на подобие 'посмотри на изображение':
+   - Автоматически проанализируйте изображение
+   - Опишите что вы видите на русском языке
+   - Тебе дается текстовая информация, которая может быть полезна для анализа
+4. Если пользователь просит нарисовать или сгенерировать изображение:
    - Начните ответ с [GENERATE_IMAGE]
-   - Напишите детальный промпт на английском языке
+   - Напишите детальный промпт на ангийском языке
    - Завершите промпт строкой [/GENERATE_IMAGE]
    - Продолжите обычный ответ на русском языке
+5. В режиме размышления:
+   - Используйте [THINKING_STEP] для обозначения шага размышления
+   - Используйте [FINAL_ANSWER] для итогового ответа
+   - Старайтесь подробно описывать ход мыслей
 """
 
 def test_code(code: str, file_type: str = ".py") -> Dict[str, Any]:
@@ -80,7 +102,7 @@ def process_file(file):
         return None
         
     try:
-        # Получаем расширение файла
+        # Получаем расширение файл��
         file_extension = file.name.lower().split('.')[-1] if hasattr(file, 'name') else ''
         
         # Список поддерживаемых форматов изображений
@@ -132,7 +154,7 @@ def generate_image(prompt: str) -> str:
     try:
         client = Client()
         response = client.images.generate(
-            model="flux-pro",
+            model="flux",
             prompt=prompt,
             response_format="url"
         )
@@ -141,20 +163,22 @@ def generate_image(prompt: str) -> str:
         return f"Ошибка при генерации изобраения: {str(e)}"
 
 def process_image(image_input) -> str:
-    """Обработка изображения и распознавание объектов через YOLOv8"""
+    """Обработка изображения и распознавание объектов через YOLOv8 и текста через EasyOCR"""
     try:
         # Загружаем модель YOLOv8n
-        model = YOLO('s.pt')
+        model = YOLO('yolov8n.pt')
         
-        # Если передан URL
+        # Инициализируем EasyOCR для русского и английского языков
+        reader = easyocr.Reader(['ru', 'en'])
+        
+        # Обработка входного изображения
         if isinstance(image_input, str):
             response = requests.get(image_input)
             image = Image.open(io.BytesIO(response.content))
-        # Если передан объект изображения
         elif isinstance(image_input, Image.Image):
             image = image_input
         else:
-            return "❌ Неподдерживаемый формат изображения"
+            return "[IMAGE]\n❌ Неподдерживаемый формат изображения\n[/IMAGE]"
         
         # Конвертируем изображение в RGB если оно в RGBA
         if image.mode == 'RGBA':
@@ -163,9 +187,12 @@ def process_image(image_input) -> str:
         # Сохраняем изображение во временный файл для обработки
         with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
             image.save(tmp.name, format='JPEG')
-            # Запускаем ра��познавание
+            # Запускаем распознавание объектов
             results = model(tmp.name)
             
+            # Распознаем текст
+            text_results = reader.readtext(tmp.name)
+            
         # Собираем найденные объекты
         detected_objects = []
         for r in results:
@@ -174,12 +201,30 @@ def process_image(image_input) -> str:
                 class_name = model.names[class_id]
                 detected_objects.append(class_name)
         
-        if not detected_objects:
-            return "Я ничего не вижу на этом изображении."
-            
-        # Переводим объекты на русский
-        objects_str = ", ".join(detected_objects)
+        # Собираем найденный текст
+        detected_text = []
+        for detection in text_results:
+            text = detection[1]
+            if text.strip():  # Проверяем, что текст не пустой
+                detected_text.append(text)
         
+        if not detected_objects and not detected_text:
+            return """
+<div class="image-analysis-animation">
+    <div class="analysis-text">К сожалению, я не смог распознать объекты на этом изображении</div>
+</div>
+"""
+            
+        # Формируем сообщение для GPT
+        prompt = "Я на этом изображении вижу "
+        if detected_objects:
+            objects_str = ", ".join(detected_objects)
+            prompt += f"следующие объекты: {objects_str}. "
+            
+        if detected_text:
+            text_str = ", ".join(detected_text)
+            prompt += f"Также на изображении есть текст: {text_str}"
+            
         messages = [
             {
                 "role": "system",
@@ -188,93 +233,166 @@ def process_image(image_input) -> str:
                 1. Перевести названия объектов на русский язык
                 2. Описать что ты видишь простыми словами
                 3. Всегда отвечать на русском языке
-                4. Начинать ответ со слов "Я на этом изображении вижу..."
-                5. Никогда не говри "Похоже,что у вас есть описание изображения..."
+                4. Если есть текст, упомянуть его в описании
+                5. Никогда не говори "Похоже,что у вас есть описание изображения..."
                 """
             },
             {
                 "role": "user",
-                "content": f"Переведи и опиши эти объекты: {objects_str}"
+                "content": prompt
             }
         ]
         
         response = g4f.ChatCompletion.create(
             model="gpt-4o",
-            messages=messages,
-            # provider=g4f.Provider.Airforce
+            messages=messages
         )
         
-        # Сохраняем результат в истории чата
-        if isinstance(response, str):
-            return response
-        elif isinstance(response, dict) and "content" in response:
-            return response["content"]
-        else:
-            # Если что-то пошло не так, хотя бы покажем список объектов
-            return f"Я на этом изображении вижу: {objects_str}"
-            
+        return response if isinstance(response, str) else prompt
+
     except Exception as e:
         return f"❌ Ошибка при обработке изображения: {str(e)}"
     finally:
         if 'tmp' in locals():
             Path(tmp.name).unlink(missing_ok=True)
 
-def chat_response(message, history, model_name, direct_mode, uploaded_file=None):
+async def chat_response(message, history, model_name, direct_mode, thinking_depth=1.0, uploaded_file=None):
     messages = [{"role": "system", "content": SYSTEM_PROMPT}]
     history = history or []
     history.append({"role": "user", "content": message})
     history.append({"role": "assistant", "content": ""})
-    print(f"Получено сообщение: {message}")
-    print(f"Модель: {model_name}")
-    print(f"Прямая генерация: {direct_mode}")
-    print(f"Загруженный файл: {uploaded_file}")
+    
     try:
-        if direct_mode:
-            # Прямая отправка в нейронку для генерации изображения
-            image_url = generate_image(message)
-            if not image_url.startswith("Ошибка"):
-                # Анализируем изображение на наличие текста
-                image_analysis = process_image(image_url)
-                history[-1]["content"] = f"![Generated Image]({image_url})\n\n{image_analysis}"
-            else:
-                history[-1]["content"] = f"��� {image_url}"
+        if model_name == "GPT-4o THINK":
+            client = AsyncClient()
+            min_steps = 3
+            max_steps = 20
+            num_steps = int(min_steps + (max_steps - min_steps) * (thinking_depth / 10.0))
+            
+            thinking_prompt = f"""Ты - система глубокого анализа. 
+            СТРОГО СОБЛЮДАЙ ФОРМАТ:
+            1. Каждый шаг должен быть в отдельных тегах [THINKING_STEP]текст шага[/THINKING_STEP]
+            2. После ВСЕХ шагов размышления пиши [FINAL_ANSWER]итоговый ответ[/FINAL_ANSWER]
+            3. Не пиши ничего между тегами
+            4. Не используй теги внутри других тегов
+            5. Обязательно сделай {num_steps} шагов, не больше и не меньше
+            
+            Глубина анализа: {thinking_depth:.1f}/10
+            
+            Вопрос для анализа: {message}
+            """
+            
+            thinking_html = f"""
+            <div class="thinking-animation">
+                <div class="thinking-step">🤔 Начинаю анализ (глубина: {thinking_depth:.1f}, шагов: {num_steps})</div>
+            </div>
+            """
+            history[-1]["content"] = thinking_html
             yield history, *[gr.update(visible=False) for _ in range(6)]
+
+            try:
+                stream = await client.chat.completions.create(
+                    model="gpt-4o",
+                    messages=[{"role": "user", "content": thinking_prompt}],
+                    stream=True
+                )
+                
+                thinking_steps = []
+                current_text = ""
+                
+                async for chunk in stream:
+                    if chunk.choices and chunk.choices[0].delta.content:
+                        current_text += chunk.choices[0].delta.content
+                        
+                        while "[THINKING_STEP]" in current_text and "[/THINKING_STEP]" in current_text:
+                            start = current_text.find("[THINKING_STEP]")
+                            end = current_text.find("[/THINKING_STEP]")
+                            if start != -1 and end != -1:
+                                step = current_text[start + len("[THINKING_STEP]"):end].strip()
+                                if step and step not in thinking_steps:
+                                    thinking_steps.append(step)
+                                    thinking_html = f"""
+                                    <div class="thinking-animation">
+                                        <div class="thinking-step">🤔 Процесс размышления ({len(thinking_steps)}/{num_steps}):</div>
+                                    """
+                                    for i, s in enumerate(thinking_steps, 1):
+                                        thinking_html += f'<div class="thinking-step">Шаг {i}: {s}</div>'
+                                    thinking_html += '</div>'
+                                    history[-1]["content"] = thinking_html
+                                    yield history, *[gr.update(visible=False) for _ in range(6)]
+                                current_text = current_text[end + len("[/THINKING_STEP]"):]
+                        
+                            if "[FINAL_ANSWER]" in current_text and "[/FINAL_ANSWER]" in current_text:
+                                start = current_text.find("[FINAL_ANSWER]")
+                                end = current_text.find("[/FINAL_ANSWER]")
+                                final_answer = current_text[start + len("[FINAL_ANSWER]"):end].strip()
+                                
+                                thinking_html = f"""
+                                <div class="thinking-animation">
+                                    <div class="thinking-step">✨ Результат анализа (выполнено шагов: {len(thinking_steps)}/{num_steps}):</div>
+                                """
+                                for i, step in enumerate(thinking_steps, 1):
+                                    thinking_html += f'<div class="thinking-step">Шаг {i}: {step}</div>'
+                                thinking_html += f'<div class="thinking-conclusion">{final_answer}</div>'
+                                thinking_html += '</div>'
+                                history[-1]["content"] = thinking_html
+                                yield history, *[gr.update(visible=False) for _ in range(6)]
+                                break
+
+            except Exception as e:
+                history[-1]["content"] = f"❌ Ошибка при анализе: {str(e)}"
+                yield history, *[gr.update(visible=False) for _ in range(6)]
+            finally:
+                await client.close()
+            
             return
+            
+        else:
+            # Обычный режим работы
+            if direct_mode:
+                # Прямая отправка в нейронку для генерации изображения
+                image_url = generate_image(message)
+                if not image_url.startswith("Ошибка"):
+                    image_analysis = process_image(image_url)
+                    history[-1]["content"] = f"![Generated Image]({image_url})\n\n{image_analysis}"
+                else:
+                    history[-1]["content"] = f"❌ {image_url}"
+                yield history, *[gr.update(visible=False) for _ in range(6)]
+                return
 
-        # Начальные значения
-        yield (
-            history,
-            gr.update(visible=False),
-            gr.update(visible=False),
-            gr.update(visible=False),
-            "",
-            gr.update(visible=False),
-            gr.update(visible=False)
-        )
-        
-        if uploaded_file:
-            file_content = process_file(uploaded_file)
-            if file_content:
-                message = f"Файл содержит:\n```\n{file_content}\n```\n\n{message}"
-
-        # Формируем историю сообщений
-        for msg in history[:-2]:
-            messages.append({"role": msg["role"], "content": msg["content"]})
-        messages.append({"role": "user", "content": str(message)})
-
-        partial_message = ""
-        code_block = None
-        
-        response = g4f.ChatCompletion.create(
-            model=AVAILABLE_MODELS.get(model_name, "gpt-4o"),
-            messages=messages,
-            stream=True,
-            provider=g4f.Provider.Airforce
-        )
-        
-        for chunk in response:
-            if chunk:
-                if isinstance(chunk, str):
+            # Начальные значения
+            yield (
+                history,
+                gr.update(visible=False),
+                gr.update(visible=False),
+                gr.update(visible=False),
+                "",
+                gr.update(visible=False),
+                gr.update(visible=False)
+            )
+            
+            if uploaded_file:
+                file_content = process_file(uploaded_file)
+                if file_content:
+                    message = f"Файл содержит:\n```\n{file_content}\n```\n\n{message}"
+
+            # Формируем историю сообщений
+            for msg in history[:-2]:
+                messages.append({"role": msg["role"], "content": msg["content"]})
+            messages.append({"role": "user", "content": str(message)})
+
+            partial_message = ""
+            code_block = None
+            
+            response = g4f.ChatCompletion.create(
+                model=AVAILABLE_MODELS.get(model_name, "gpt-4o"),
+                messages=messages,
+                stream=True,
+                provider=g4f.Provider.Airforce
+            )
+            
+            for chunk in response:
+                if chunk and isinstance(chunk, str):
                     partial_message += chunk
                     
                     # Проверяем на запрос генерации изображения
@@ -283,7 +401,7 @@ def chat_response(message, history, model_name, direct_mode, uploaded_file=None)
                         end_idx = partial_message.find("[/GENERATE_IMAGE]")
                         image_prompt = partial_message[start_idx:end_idx].strip()
                         
-                        # Показываем статус генерации
+                        # Показываем статус ге��ерации
                         history[-1]["content"] = """
 <div class="generating-animation">
     <div class="generating-text">Генерация изображения...</div>
@@ -311,13 +429,15 @@ def chat_response(message, history, model_name, direct_mode, uploaded_file=None)
                         code_end = partial_message.find("```", code_start)
                         if code_end != -1:
                             code_block = partial_message[code_start:code_end].strip()
-        
-        # В конце убираем курсор
-        history[-1]["content"] = partial_message
-        yield history, *[gr.update(visible=True if code_block else False) for _ in range(6)]
+            
+            # В конце убираем курсор
+            history[-1]["content"] = partial_message
+            yield history, *[gr.update(visible=True if code_block else False) for _ in range(6)]
 
     except Exception as e:
         print(f"Error: {e}")
+        if not history:
+            history = [{"role": "user", "content": message}, {"role": "assistant", "content": ""}]
         history[-1]["content"] = f"❌ Произошла ошибка: {str(e)}"
         yield (
             history,
@@ -371,7 +491,7 @@ def create_interface():
         input_background_fill="#2d2d2d",
     )
 
-    # Обновляем CSS стили для управления цветом кода
+    # Обновляем CSS стили для управлен��я цветом кода
     css = """
     .gradio-container { 
         background-color: #1a1a1a !important;
@@ -511,8 +631,125 @@ def create_interface():
     .footer {
         display: none !important;
     }
+    
+    /* Добавляем анимацию для просмотра изображения */
+    .image-analysis-animation {
+        position: relative;
+        width: 100%;
+        min-height: 100px;
+        background: linear-gradient(45deg, #2d2d2d, #3d3d3d);
+        border-radius: 15px;
+        overflow: hidden;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        margin: 10px 0;
+    }
+
+    .analysis-text {
+        color: white;
+        font-size: 16px;
+        z-index: 2;
+        text-align: center;
+        animation: pulse 1.5s infinite;
+    }
+
+    .image-analysis-animation::before {
+        content: '';
+        position: absolute;
+        width: 100%;
+        height: 100%;
+        background: linear-gradient(90deg, 
+            transparent 0%,
+            rgba(255,255,255,0.1) 50%,
+            transparent 100%);
+        animation: scanning 2s linear infinite;
+    }
+
+    @keyframes scanning {
+        0% { transform: translateX(-100%); }
+        100% { transform: translateX(100%); }
+    }
+
+    .thinking-animation {
+        position: relative;
+        width: 100%;
+        min-height: 100px;
+        background: linear-gradient(45deg, #1a1a1a, #2d2d2d);
+        border-radius: 15px;
+        overflow: hidden;
+        margin: 10px 0;
+        padding: 20px;
+        border-left: 4px solid #4a90e2;
+        transition: all 0.3s ease;
+    }
+
+    .thinking-animation:hover {
+        background: linear-gradient(45deg, #202020, #333333);
+    }
+
+    .thinking-step {
+        color: #b0b0b0;
+        font-style: italic;
+        margin-bottom: 10px;
+        padding-left: 20px;
+        border-left: 2px solid #4a90e2;
+        opacity: 0;
+        transform: translateY(10px);
+        animation: fadeInStep 0.5s ease-in-out forwards;
+    }
+
+    .thinking-conclusion {
+        color: white;
+        font-weight: bold;
+        margin-top: 15px;
+        padding: 10px;
+        background: rgba(74, 144, 226, 0.1);
+        border-radius: 8px;
+        border-left: 4px solid #4a90e2;
+    }
+
+    @keyframes fadeInStep {
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+
+    .typing-cursor {
+        display: inline-block;
+        width: 2px;
+        height: 15px;
+        background: #4a90e2;
+        margin-left: 5px;
+        animation: blink 1s infinite;
+    }
+
+    @keyframes blink {
+        50% { opacity: 0; }
+    }
+    
+    /* Стили для слайдера глубины размышления */
+    .thinking-depth-slider {
+        margin-top: 10px;
+        padding: 8px;
+        background: rgba(74, 144, 226, 0.1);
+        border-radius: 8px;
+        border-left: 4px solid #4a90e2;
+    }
+
+    /* Индикатор глубины размышления в сообщении */
+    .thinking-depth-indicator {
+        font-size: 0.9em;
+        color: #4a90e2;
+        margin-bottom: 10px;
+        font-style: italic;
+    }
     """
 
+    # Добавте этот скрипт в create_interface()
+    
+
     
     with gr.Blocks(theme=theme, css=css) as demo:
         # gr.Markdown("# 💬 AI Chat Assistant")
@@ -531,7 +768,7 @@ def create_interface():
                     render_markdown=True
                 )
                 
-                # Добавляем компоненты для вывода
+                # Добавляем омпоненты для вывода
                 output_text = gr.Textbox(
                     label="Вывод",
                     interactive=False,
@@ -570,6 +807,17 @@ def create_interface():
                     value="GPT-4o",
                     label="Модель"
                 )
+                
+                # Добавляем слайдер глубины размышления (изначально скрытый)
+                thinking_depth = gr.Slider(
+                    minimum=0.1,
+                    maximum=10.0,
+                    value=1.0,
+                    step=0.1,
+                    label="Глубина размышления",
+                    visible=False
+                )
+                
                 direct_mode = gr.Checkbox(
                     label="Прямая генерация (без обрботки прмпта)",
                     value=False
@@ -633,24 +881,16 @@ def create_interface():
         # Обработчики событий
         msg.submit(
             fn=chat_response,
-            inputs=[msg, chatbot, model, direct_mode, file_output],
+            inputs=[msg, chatbot, model, direct_mode, thinking_depth, file_output],
             outputs=[chatbot, output_text, error_text, ask_help_btn, current_code, analyze_btn, run_btn],
-            api_name=None,  # Изменим с False на None
-            show_progress=True
-        ).then(
-            fn=lambda: gr.update(value=""),
-            outputs=[msg]
+            api_name=None
         )
 
         submit.click(
             fn=chat_response,
-            inputs=[msg, chatbot, model, direct_mode, file_output],
+            inputs=[msg, chatbot, model, direct_mode, thinking_depth, file_output],
             outputs=[chatbot, output_text, error_text, ask_help_btn, current_code, analyze_btn, run_btn],
-            api_name=None,  # Изменим с False на None
-            show_progress=True
-        ).then(
-            fn=lambda: gr.update(value=""),
-            outputs=[msg]
+            api_name=None
         )
 
         ask_help_btn.click(
@@ -676,22 +916,32 @@ def create_interface():
             outputs=[chatbot, output_text, error_text, ask_help_btn, current_code]
         )
 
+        # Добавляем обработчик изменения модели
+        def update_thinking_depth_visibility(model_name):
+            return gr.update(visible=model_name == "GPT-4o THINK")
+        
+        model.change(
+            fn=update_thinking_depth_visibility,
+            inputs=[model],
+            outputs=[thinking_depth]
+        )
+
     return demo
 
 
 if __name__ == "__main__":
     demo = create_interface()
-   
-     
-    # Запускаем мониторинг изменений в тдельном потоке
-
     
-    demo.launch(
-        show_api=False,
-        show_error=True,
-        favicon_path=None,
-        auth=None,
-        # quiet=True,  # Добавим этот параметр
-      
-
-    )
+    try:
+        demo.launch(
+            server_name="127.0.0.1",  # Явно указываем хост
+            server_port=7860,         # Явно указываем порт
+            show_api=False,
+            show_error=True,
+            debug=True
+        )
+    except Exception as e:
+        print(f"Ошибка запуска: {e}")
+    finally:
+        # Закрываем цикл событий
+        loop.close()