Update app.py

app.py

@@ -1,170 +1,161 @@
-import os
 import gradio as gr
 import edge_tts
 import asyncio
 import tempfile
 import re
-import logging
-from pathlib import Path
+from typing import Optional, Tuple, Dict
 from huggingface_hub import InferenceClient
 
-# Конфигурация
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-MAX_TEXT_LENGTH = 5000
-TEMP_FILES = []
+# Константы
+DEFAULT_RATE = 0
+DEFAULT_PITCH = 0
+HF_API_KEY = "YOUR_API_KEY"  # Замените на ваш API ключ
 
-# Инициализация клиентов
-image_client = None
-chat_client = None
-tts_voices = []
+# Инициализация клиента для генерации текста
+text_client = InferenceClient(provider="together", api_key=HF_API_KEY)
 
-# Стиль интерфейса
-theme = gr.themes.Soft()
+# Кастомная цветовая схема
+theme = gr.themes.Default(
+    primary_hue="orange",
+    secondary_hue="yellow",
+).set(
+    button_primary_background="linear-gradient(90deg, #ff9a00, #ffd700)",
+    button_primary_background_hover="linear-gradient(90deg, #ff8c00, #ffcc00)",
+    slider_color="#ff9a00",
+    block_background="#fff5e6"
+)
 
-def initialize_clients(api_key):
-    global image_client, chat_client, tts_voices
-    try:
-        # Инициализация клиентов API
-        image_client = InferenceClient(token=api_key)
-        chat_client = InferenceClient(provider="together", api_key=api_key)
-        
-        # Получение списка голосов для TTS
-        asyncio.run(load_tts_voices())
-        return True
-    except Exception:
-        return False
-
-async def load_tts_voices():
-    global tts_voices
+async def get_voices() -> Dict[str, str]:
     voices = await edge_tts.list_voices()
-    tts_voices = [f"{v['ShortName']} ({v['Gender']})" for v in voices]
+    return {
+        f"{v['ShortName']} - {v['Locale']} ({v['Gender']})": v['ShortName']
+        for v in voices
+    }
 
-# Функция очистки текста
-def clean_text(text):
-    text = re.sub(r'[*_~><`#%$^]', '', text)
-    return text.strip()
-
-# Генерация аудио
-async def generate_audio(text, voice):
+async def text_to_speech(text: str, voice: str, rate: int, pitch: int) -> Tuple[Optional[str], Optional[str]]:
     if not text.strip():
-        return None
-    
+        return None, None
     try:
-        text = clean_text(text)
-        communicate = edge_tts.Communicate(text, voice.split()[0])
-        
+        voice_short_name = voice.split(" - ")[0]
+        communicate = edge_tts.Communicate(
+            text, 
+            voice_short_name,
+            rate=f"{rate:+d}%",
+            pitch=f"{pitch:+d}Hz"
+        )
         with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
-            tmp_path = tmp_file.name
-            await communicate.save(tmp_path)
-            TEMP_FILES.append(tmp_path)
-            return tmp_path
-            
+            await communicate.save(tmp_file.name)
+            return tmp_file.name, None
     except Exception:
-        return None
+        return None, None
 
-# Генерация изображений
-def generate_image(prompt):
-    if not prompt.strip():
-        return None
-    
-    try:
-        response = image_client.text_to_image(
-            prompt.strip(),
-            model="nerijs/dark-fantasy-illustration-flux",
-            negative_prompt="text, watermark, low quality",
-            guidance_scale=9,
-            height=512,
-            width=512
-        )
-        
-        with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as tmp_file:
-            tmp_file.write(response)
-            TEMP_FILES.append(tmp_file.name)
-            return tmp_file.name
-            
-    except Exception:
-        return None
+# ADD PROMPT HERE - Вставьте ваш промпт для генерации текста
+SYSTEM_PROMPT = """
+[Здесь будет ваш системный промпт]
+"""
 
-# Генерация текста
-async def generate_text(input_text):
-    if not input_text.strip():
-        return None
-    
+async def generate_detailed_description(input_text: str) -> str:
     try:
-        completion = chat_client.chat.completions.create(
+        # Добавьте вашу логику обработки промпта
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": input_text}
+        ]
+        
+        completion = text_client.chat.completions.create(
             model="deepseek-ai/DeepSeek-R1",
-            messages=[{"role": "user", "content": input_text}],
+            messages=messages,
             max_tokens=500
         )
         return completion.choices[0].message.content
     except Exception:
-        return None
+        return ""
 
-# Интерфейс
-def create_interface():
+async def tts_interface(text: str, voice: str, rate: int, pitch: int):
+    return await text_to_speech(text, voice, rate, pitch)
+
+async def create_demo():
+    voices = await get_voices()
+    
     with gr.Blocks(theme=theme, title="AI Studio Pro") as demo:
-        gr.Markdown("# 🎙️ Full AI Studio")
-        
-        # Секция API ключа (скрытая)
-        api_key = gr.Textbox(
-            value=os.environ.get("HF_API_KEY", ""),
-            visible=False
-        )
+        gr.Markdown("# 🧡💛 AI Creative Studio")
         
+        # Вкладки
         with gr.Tabs():
             # Вкладка TTS
-            with gr.Tab("🔊 Text-to-Speech"):
+            with gr.Tab("🔊 Генерация речи"):
                 with gr.Row():
                     with gr.Column():
-                        tts_text = gr.Textbox(label="Text to speak", lines=5)
-                        tts_voice = gr.Dropdown(
-                            label="Voice",
-                            choices=tts_voices,
-                            value="en-US-ChristopherNeural (Male)" if tts_voices else None
+                        text_input = gr.Textbox(
+                            label="Входной текст",
+                            lines=5,
+                            placeholder="Введите текст для озвучки...",
+                            elem_classes="orange-border"
                         )
-                        tts_btn = gr.Button("Generate Speech", variant="primary")
+                        with gr.Row():
+                            lang_dropdown = gr.Dropdown(
+                                choices=["Все языки", "en", "ru", "es", "fr", "de"],
+                                value="Все языки",
+                                label="Выберите язык"
+                            )
+                            voice_dropdown = gr.Dropdown(
+                                choices=list(voices.keys()),
+                                label="Выберите голос",
+                                interactive=True
+                            )
+                        with gr.Row():
+                            rate_slider = gr.Slider(-50, 50, 0, label="Скорость")
+                            pitch_slider = gr.Slider(-20, 20, 0, label="Тон")
+                        generate_btn = gr.Button("Сгенерировать речь", variant="primary")
                     
                     with gr.Column():
-                        tts_audio = gr.Audio(label="Generated Audio")
-                
-                tts_btn.click(
-                    generate_audio,
-                    [tts_text, tts_voice],
-                    tts_audio
-                )
-
-            # Вкладка генерации текста и изображений
-            with gr.Tab("🖼️ Text & Image Generation"):
+                        audio_output = gr.Audio(label="Результат", elem_classes="orange-border")
+        
+            # Вкладка генерации контента
+            with gr.Tab("✨ Генератор контента"):
                 with gr.Row():
                     with gr.Column():
-                        input_text = gr.Textbox(
-                            label="Input Text",
-                            placeholder="Enter text with <image>prompt</image> tags...",
-                            lines=5
+                        prompt_input = gr.Textbox(
+                            label="Краткое описание",
+                            lines=3,
+                            placeholder="Опишите идею для генерации...",
+                            elem_classes="orange-border"
                         )
-                        gen_btn = gr.Button("Generate Content", variant="primary")
+                        with gr.Accordion("Дополнительные настройки", open=False):
+                            gr.Markdown("Здесь будут дополнительные параметры")
+                        generate_content_btn = gr.Button("Сгенерировать контент", variant="primary")
                     
                     with gr.Column():
-                        output_text = gr.Textbox(label="Generated Text", interactive=False)
-                        gallery = gr.Gallery(label="Generated Images", columns=2)
-                
-                gen_btn.click(
-                    fn=lambda x: [generate_text(x)] + [generate_image(p) for p in parse_image_prompts(x)],
-                    inputs=input_text,
-                    outputs=[output_text, gallery]
-                )
+                        text_output = gr.Textbox(
+                            label="Сгенерированный текст",
+                            interactive=False,
+                            elem_classes="orange-border"
+                        )
+                        image_output = gr.Gallery(
+                            label="Сгенерированные изображения",
+                            columns=2,
+                            elem_classes="orange-border"
+                        )
 
-        return demo
+        # Обработчики событий
+        generate_btn.click(
+            tts_interface,
+            [text_input, voice_dropdown, rate_slider, pitch_slider],
+            audio_output
+        )
+        
+        generate_content_btn.click(
+            generate_detailed_description,
+            prompt_input,
+            text_output
+        )
+
+    return demo
+
+async def main():
+    demo = await create_demo()
+    demo.queue()
+    demo.launch()
 
-# Запуск
 if __name__ == "__main__":
-    try:
-        demo = create_interface()
-        demo.launch(server_port=7860)
-    finally:
-        for file in TEMP_FILES:
-            try:
-                Path(file).unlink(missing_ok=True)
-            except Exception:
-                pass
+    asyncio.run(main())