Update app.py

app.py

@@ -4,13 +4,22 @@ import time
 import json
 import base64
 import asyncio
+import threading
 import datetime
 from io import BytesIO
-from typing import AsyncGenerator
+from typing import AsyncGenerator, List, Tuple, Optional
 
 import aiohttp
 import gradio as gr
 from PIL import Image
+import warnings
+
+# 忽略asyncio警告
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+# 设置事件循环策略（修复Python 3.13+兼容性问题）
+if hasattr(asyncio, 'WindowsProactorEventLoopPolicy') and isinstance(asyncio.get_event_loop_policy(), asyncio.WindowsProactorEventLoopPolicy):
+    asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
 
 SAMBANOVA_API_KEY = os.getenv("SAMBANOVA_API_KEY", "").strip()
 HF_TOKEN = os.getenv("HF_TOKEN", "").strip()
@@ -46,6 +55,8 @@ CSS = """
 :root{--primary:#00C896;--secondary:#00FFE0;--bg:#000;--border:rgba(0,200,150,.35);}
 body,.gradio-container{background:#000!important; color: #fff !important;}
 .panel{border:1px solid var(--border);border-radius:16px;padding:12px}
+.dark .gradio-container {background: #000 !important;}
+.dark .gr-button-primary {background: linear-gradient(45deg, #00C896, #00FFE0) !important;}
 """
 
 def log_event(data: dict):
@@ -62,14 +73,20 @@ def save_generation(content, model_name, type="text"):
 
 def smart_select(prompt: str) -> str:
     p = prompt.lower()
-    if any(x in p for x in ["código", "python", "script"]): return "DeepSeek-Coder-V2"
-    if any(x in p for x in ["razona", "piensa", "matemáticas"]): return "DeepSeek-R1"
-    if any(x in p for x in ["vision", "mira", "describe"]): return "Meta-Llama-3.2-11B-Vision-Instruct"
+    if any(x in p for x in ["código", "python", "script", "programa", "code"]): 
+        return "DeepSeek-Coder-V2"
+    if any(x in p for x in ["razona", "piensa", "matemáticas", "math", "logic"]): 
+        return "DeepSeek-R1"
+    if any(x in p for x in ["vision", "mira", "describe", "imagen", "image"]): 
+        return "Meta-Llama-3.2-11B-Vision-Instruct"
+    if any(x in p for x in ["audio", "sonido", "speech", "voz"]):
+        return "Qwen/Qwen2-Audio-7B-Instruct"
     return "DeepSeek-V3.1"
 
-async def stream_samba(model, prompt, temp, tokens):
+async def stream_samba(model: str, prompt: str, temp: float, tokens: int) -> AsyncGenerator[str, None]:
+    """Stream response from Sambanova API"""
     url = "https://api.sambanova.ai/v1/chat/completions"
-    headers = {"Authorization": f"Bearer {SAMBANOVA_API_KEY}"}
+    headers = {"Authorization": f"Bearer {SAMBANOVA_API_KEY}", "Content-Type": "application/json"}
     payload = {
         "model": model,
         "messages": [{"role": "user", "content": prompt}],
@@ -77,70 +94,238 @@ async def stream_samba(model, prompt, temp, tokens):
         "max_tokens": tokens,
         "stream": True
     }
+    
     full_res = ""
-    async with aiohttp.ClientSession() as session:
-        async with session.post(url, headers=headers, json=payload) as resp:
-            async for line in resp.content:
-                line = line.decode("utf-8").strip()
-                if line.startswith("data: "):
-                    data_str = line[6:]
-                    if data_str == "[DONE]": break
-                    try:
-                        data = json.loads(data_str)
-                        delta = data["choices"][0]["delta"].get("content", "")
-                        full_res += delta
-                        yield full_res
-                    except: continue
-    save_generation(full_res, model)
-    log_event({"model": model, "prompt": prompt})
-
-async def run_reve(prompt, n):
+    timeout = aiohttp.ClientTimeout(total=60.0)
+    
+    try:
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.post(url, headers=headers, json=payload) as resp:
+                if resp.status != 200:
+                    error_text = await resp.text()
+                    yield f"Error {resp.status}: {error_text}"
+                    return
+                
+                async for line in resp.content:
+                    if line:
+                        line = line.decode("utf-8").strip()
+                        if line.startswith("data: "):
+                            data_str = line[6:]
+                            if data_str == "[DONE]":
+                                break
+                            try:
+                                data = json.loads(data_str)
+                                if "choices" in data and data["choices"]:
+                                    delta = data["choices"][0]["delta"].get("content", "")
+                                    full_res += delta
+                                    yield full_res
+                            except json.JSONDecodeError:
+                                continue
+    except Exception as e:
+        yield f"Error de conexión: {str(e)}"
+    
+    if full_res:
+        save_generation(full_res, model)
+        log_event({"model": model, "prompt": prompt[:100], "response_length": len(full_res)})
+
+async def run_reve(prompt: str, n: int) -> List[Image.Image]:
+    """Generate images using REVE API"""
+    if not REVE_API_KEY:
+        return []
+    
     url = "https://api.reve.com/v1/image/create"
-    headers = {"Authorization": f"Bearer {REVE_API_KEY}"}
+    headers = {"Authorization": f"Bearer {REVE_API_KEY}", "Content-Type": "application/json"}
     imgs = []
-    async with aiohttp.ClientSession() as session:
-        for _ in range(n):
-            async with session.post(url, headers=headers, json={"prompt": prompt}) as r:
-                if r.status == 200:
-                    j = await r.json()
-                    for b in j.get("images", []):
-                        imgs.append(Image.open(BytesIO(base64.b64decode(b))))
+    
+    try:
+        timeout = aiohttp.ClientTimeout(total=120.0)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            tasks = []
+            for i in range(n):
+                task = session.post(url, headers=headers, json={"prompt": prompt})
+                tasks.append(task)
+            
+            responses = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            for response in responses:
+                if isinstance(response, Exception):
+                    continue
+                if response.status == 200:
+                    try:
+                        data = await response.json()
+                        for img_data in data.get("images", []):
+                            img_bytes = base64.b64decode(img_data)
+                            img = Image.open(BytesIO(img_bytes))
+                            imgs.append(img)
+                    except Exception as e:
+                        print(f"Error procesando imagen: {e}")
+    except Exception as e:
+        print(f"Error en REVE API: {e}")
+    
     return imgs
 
-def handle_execution(model, prompt, temp, tokens, n):
+def handle_execution(model: str, prompt: str, temp: float, tokens: int, n: int):
+    """Handle execution based on model selection"""
+    if not prompt.strip():
+        return "Por favor ingresa un comando.", []
+    
     active_model = smart_select(prompt) if model == "AUTO-SELECT" else model
     
+    # Verificar que tenemos la API key necesaria
+    if active_model in SAMBA_MODELS and not SAMBANOVA_API_KEY:
+        return "Error: Falta SAMBANOVA_API_KEY en las variables de entorno.", []
+    
     if active_model == "REVE":
-        imgs = asyncio.run(run_reve(prompt, n))
-        return "Imágenes generadas.", imgs
+        if not REVE_API_KEY:
+            return "Error: Falta REVE_API_KEY en las variables de entorno.", []
+        
+        # Ejecutar en un nuevo evento de asyncio
+        try:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            images = loop.run_until_complete(run_reve(prompt, n))
+            loop.close()
+            return f"✅ Generadas {len(images)} imágenes con REVE.", images
+        except Exception as e:
+            return f"Error generando imágenes: {str(e)}", []
     
+    # Para modelos de texto, retornamos un generador
     return stream_samba(active_model, prompt, temp, tokens)
 
-with gr.Blocks(title="BATUTO X • Neurocore") as demo:
-    gr.HTML("<h1 style='color:#00C896; text-align:center;'>⚡ BATUTO X • NEUROCORE PRO</h1>")
-    
-    with gr.Row():
-        with gr.Column(scale=1):
-            model_opt = gr.Dropdown(ALL_MODELS, value="AUTO-SELECT", label="Model")
-            temp_opt = gr.Slider(0, 1.5, 0.7, label="Temperature")
-            tokens_opt = gr.Slider(128, 8192, 2048, label="Max Tokens")
-            num_opt = gr.Slider(1, 4, 1, step=1, label="Image Count")
+def create_interface():
+    """Create the Gradio interface"""
+    with gr.Blocks(title="BATUTO X • Neurocore", css=CSS, theme=gr.themes.Default(primary_hue="emerald", neutral_hue="zinc")) as demo:
+        gr.HTML("""
+        <div style="text-align: center; padding: 20px; background: linear-gradient(45deg, #000, #001a14); border-radius: 16px; margin-bottom: 20px;">
+            <h1 style="color: #00C896; margin: 0; font-size: 2.5em;">⚡ BATUTO X • NEUROCORE PRO</h1>
+            <p style="color: #00FFE0; margin-top: 10px;">Interfaz de Generación Multimodal Avanzada</p>
+        </div>
+        """)
         
-        with gr.Column(scale=2):
-            prompt_input = gr.Textbox(lines=5, label="Input", placeholder="Comando...")
-            send_btn = gr.Button("EJECUTAR", variant="primary")
-
-    canvas = gr.Textbox(lines=12, label="Output", interactive=False)
-    gallery = gr.Gallery(label="Gallery", columns=2)
-
-    send_btn.click(handle_execution, [model_opt, prompt_input, temp_opt, tokens_opt, num_opt], [canvas, gallery])
+        with gr.Row():
+            with gr.Column(scale=1):
+                with gr.Group():
+                    model_opt = gr.Dropdown(
+                        ALL_MODELS, 
+                        value="AUTO-SELECT", 
+                        label="🧠 Modelo",
+                        info="Selecciona un modelo o usa AUTO-SELECT para detección inteligente"
+                    )
+                    temp_opt = gr.Slider(
+                        0, 1.5, 0.7, 
+                        label="🌡️ Temperature",
+                        info="Controla la aleatoriedad (0 = determinístico, 1.5 = muy creativo)"
+                    )
+                    tokens_opt = gr.Slider(
+                        128, 8192, 2048, 
+                        step=128,
+                        label="📏 Máximo Tokens",
+                        info="Longitud máxima de la respuesta"
+                    )
+                    num_opt = gr.Slider(
+                        1, 4, 1, step=1, 
+                        label="🖼️ Cantidad de Imágenes",
+                        visible=False,
+                        info="Solo aplica para modelos de imagen"
+                    )
+            
+            with gr.Column(scale=2):
+                with gr.Group():
+                    prompt_input = gr.Textbox(
+                        lines=5, 
+                        label="💬 Entrada",
+                        placeholder="Escribe tu comando aquí...\nEjemplo: 'Genera un código Python para ordenar una lista' o 'Describe esta imagen: [URL o descripción]'",
+                        elem_classes=["prompt-box"]
+                    )
+        
+        send_btn = gr.Button(
+            "🚀 EJECUTAR COMANDO", 
+            variant="primary", 
+            size="lg",
+            elem_classes=["execute-btn"]
+        )
+        
+        with gr.Group():
+            canvas = gr.Textbox(
+                lines=12, 
+                label="📤 Salida",
+                interactive=False,
+                elem_classes=["output-box"]
+            )
+        
+        gallery = gr.Gallery(
+            label="🎨 Galería de Imágenes",
+            columns=2,
+            height=400,
+            visible=False
+        )
+        
+        # Mostrar/ocultar controles basado en selección de modelo
+        def toggle_controls(model):
+            if model == "REVE":
+                return [gr.Slider(visible=True), gr.Gallery(visible=True)]
+            else:
+                return [gr.Slider(visible=False), gr.Gallery(visible=False)]
+        
+        model_opt.change(
+            fn=toggle_controls,
+            inputs=model_opt,
+            outputs=[num_opt, gallery]
+        )
+        
+        # Conectar el botón
+        send_btn.click(
+            fn=handle_execution,
+            inputs=[model_opt, prompt_input, temp_opt, tokens_opt, num_opt],
+            outputs=[canvas, gallery]
+        )
+        
+        # Ejemplos
+        with gr.Accordion("📚 Ejemplos de Uso", open=False):
+            gr.Examples(
+                examples=[
+                    ["Escribe un programa en Python que implemente el algoritmo de ordenamiento quicksort", "AUTO-SELECT"],
+                    ["Explica la teoría de la relatividad de Einstein en términos simples", "AUTO-SELECT"],
+                    ["Genera una imagen de un dragón cibernético en una ciudad futurista", "REVE"],
+                    ["Analiza este código y sugiere mejoras: def factorial(n): return 1 if n==0 else n*factorial(n-1)", "AUTO-SELECT"],
+                    ["Resuelve esta ecuación: x² + 5x + 6 = 0", "AUTO-SELECT"]
+                ],
+                inputs=[prompt_input, model_opt],
+                label="Haz clic en un ejemplo para cargarlo"
+            )
+    
+    return demo
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.getenv("PORT", "7860")),
-        ssr_mode=False,
-        theme=gr.themes.Default(primary_hue="emerald", neutral_hue="zinc"),
-        css=CSS
-    )
-    
+    # Configurar logging
+    print(f"🚀 Iniciando BATUTO X Neurocore")
+    print(f"📁 Directorio de salida: {os.path.abspath(OUTPUT_DIR)}")
+    print(f"📝 Archivo de logs: {os.path.abspath(LOG_FILE)}")
+    
+    if SAMBANOVA_API_KEY:
+        print("✅ SAMBANOVA_API_KEY configurada")
+    else:
+        print("⚠️  SAMBANOVA_API_KEY no encontrada - algunos modelos no funcionarán")
+    
+    if REVE_API_KEY:
+        print("✅ REVE_API_KEY configurada")
+    else:
+        print("⚠️  REVE_API_KEY no encontrada - generación de imágenes no disponible")
+    
+    # Crear y lanzar la interfaz
+    demo = create_interface()
+    
+    try:
+        demo.launch(
+            server_name="0.0.0.0",
+            server_port=int(os.getenv("PORT", "7860")),
+            share=os.getenv("GRADIO_SHARE", "False").lower() == "true",
+            debug=False,
+            show_error=True,
+            quiet=True
+        )
+    except KeyboardInterrupt:
+        print("\n🛑 Aplicación detenida por el usuario")
+    except Exception as e:
+        print(f"❌ Error al iniciar la aplicación: {e}")
+        raise