Update app.py

app.py

@@ -1,429 +1,199 @@
-
 import os
-import gradio as gr
+import json
 import base64
+import random
 import requests
-import time
-import concurrent.futures
-from io import BytesIO
-from PIL import Image
-from openai import OpenAI
-import logging
-
-# Configuración de logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+import io
 
-# Configuración inicial
-api_key = os.getenv("SAMBANOVA_API_KEY")
-if not api_key:
-    logger.warning("SAMBANOVA_API_KEY no encontrada en variables de entorno")
-    client = None
-else:
-    try:
-        # Inicialización simple del cliente (ajusta según SDK real)
-        client = OpenAI(
-            api_key=api_key, 
-            base_url="https://api.sambanova.ai/v1"
-        )
-    except Exception as e:
-        logger.error(f"Error inicializando cliente OpenAI: {e}")
-        client = None
-
-# Configuración para la API de imágenes (ReVE como ejemplo)
-API_URL = "https://api.reve.com/v1/image/create"
-CARPETA_SALIDA = "generaciones_reve"
-os.makedirs(CARPETA_SALIDA, exist_ok=True)
+import gradio as gr
+from PIL import Image
 
-# Modelos disponibles (bloque corregido)
+# ===========================
+#   CLAVES PARA SAMBANOVA
+# ===========================
+API_KEY = os.getenv("REVE_API_KEY")
+BASE_URL = "https://api.sambanova.ai/v1"
+
+if not API_KEY:
+    raise ValueError("⚠️ ERROR: No se encontró la variable REVE_API_KEY en HuggingFace Spaces.")
+
+# ===========================
+#   FUNCIÓN SELECT MODEL
+# ===========================
+def select_model(preference):
+    if preference == "Lento 🧠 (mejor calidad)":
+        return {
+            "name": "Qwen2.5-72B-Instruct",
+            "description": "Máxima calidad de razonamiento"
+        }
+    else:
+        return {
+            "name": "Meta-Llama-3.1-8B-Instruct",
+            "description": "Rápido y eficiente"
+        }
+
+# ===========================
+#    DICCIONARIO DE MODELOS
+# ===========================
 MODELS = {
     "general_fast": {
         "name": "Meta-Llama-3.1-8B-Instruct",
         "role": "🔄 Respuestas rápidas y generales",
-        "description": "Ideal para conversaciones casuales y respuestas rápidas"
+        "description": "Conversación ligera y eficiente."
     },
     "general_smart": {
         "name": "Meta-Llama-3.3-70B-Instruct",
-        "role": "🧠 Razonamiento complejo", 
-        "description": "Para análisis profundos, lógica compleja y razonamiento avanzado"
+        "role": "🧠 Razonamiento profundo",
+        "description": "Análisis detallado y avanzado."
     },
     "coding_expert": {
         "name": "DeepSeek-V3.1",
-        "role": "💻 Programación y código",
-        "description": "Especialista en desarrollo de software, debugging y algoritmos"
+        "role": "💻 Programación y debugging",
+        "description": "Ideal para desarrollo."
     },
     "coding_alt": {
         "name": "DeepSeek-V3-0324",
         "role": "⚡ Código rápido",
-        "description": "Alternativa rápida para tareas de programación"
+        "description": "Alternativa veloz."
     },
     "massive_brain": {
-        "name": "gpt-oss-120b", 
-        "role": "🏛️ Sabiduría profunda",
-        "description": "Modelo masivo para problemas extremadamente complejos"
+        "name": "gpt-oss-120b",
+        "role": "🏛️ Sabiduría masiva",
+        "description": "Problemas pesados y complejos."
     },
     "specialized_1": {
         "name": "DeepSeek-V3.1-Terminus",
-        "role": "🎯 Tareas especializadas",
-        "description": "Para trabajos técnicos y científicos especializados"
+        "role": "🎯 Especialista técnico",
+        "description": "Tareas científicas y avanzadas."
     },
     "specialized_2": {
         "name": "Llama-3.3-Swallow-70B-Instruct-v0.4",
-        "role": "sin censura",
-        "description": "especialista en creación de prompts y estilos visuales"
+        "role": "🔥 Sin censura",
+        "description": "Modelo sin restricciones."
     },
     "multilingual": {
         "name": "Qwen3-32B",
         "role": "🌍 Multilingüe",
-        "description": "Excelente para inglés, español y múltiples idiomas"
+        "description": "Múltiples idiomas."
     },
     "arabic_special": {
         "name": "ALLaM-7B-Instruct-preview",
-        "role": "🕌 Especialista en cultura árabe y estilos visuales",
-        "description": "Experto en cultura árabe y estilos visuales del Medio Oriente"
+        "role": "🕌 Estilo árabe y moda íntima",
+        "description": "Experto en estilos del Medio Oriente."
     },
     "vision_expert": {
         "name": "Llama-4-Maverick-17B-128E-Instruct",
-        "role": "👁️ Análisis visual",
-        "description": "Experto en análisis de imágenes y contenido visual"
+        "role": "👁️ Visión avanzada",
+        "description": "Análisis de imágenes."
     }
 }
 
-# Selección de modelo basada en prompt
-def select_best_model(user_prompt):
-    if not client:
-        return MODELS["general_smart"]["name"], MODELS["general_smart"]["role"]
-
-    prompt_lower = user_prompt.lower()
-    coding_keywords = ['código', 'programar', 'python', 'javascript', 'function', 'bug', 'algoritmo', 'desarrollar']
-    complex_reasoning = ['analizar', 'filosofía', 'razonar', 'lógica', 'teoría', 'investigar', 'profundo']
-    multilingual_keywords = ['chino', 'mandarín', 'traducir', 'inglés', 'español', 'francés', 'alemán']
-    japanese_keywords = ['japonés', 'nippon', 'anime', 'manga', 'tokio', 'kanji', 'hiragana']
-    arabic_keywords = ['árabe', 'islam', 'medioriente', 'alá', 'corán', 'dubai', 'emiratos']
-    vision_keywords = ['imagen', 'foto', 'ver', 'mostrar', 'analizar imagen', 'describir imagen']
-
-    try:
-        if any(keyword in prompt_lower for keyword in coding_keywords):
-            if "rápido" in prompt_lower or "simple" in prompt_lower:
-                return MODELS["coding_alt"]["name"], MODELS["coding_alt"]["role"]
-            return MODELS["coding_expert"]["name"], MODELS["coding_expert"]["role"]
-        elif any(keyword in prompt_lower for keyword in complex_reasoning):
-            if "muy complejo" in prompt_lower or "extremadamente" in prompt_lower:
-                return MODELS["massive_brain"]["name"], MODELS["massive_brain"]["role"]
-            return MODELS["general_smart"]["name"], MODELS["general_smart"]["role"]
-        elif any(keyword in prompt_lower for keyword in japanese_keywords):
-            return MODELS["specialized_2"]["name"], MODELS["specialized_2"]["role"]
-        elif any(keyword in prompt_lower for keyword in arabic_keywords):
-            return MODELS["arabic_special"]["name"], MODELS["arabic_special"]["role"]
-        elif any(keyword in prompt_lower for keyword in multilingual_keywords):
-            return MODELS["multilingual"]["name"], MODELS["multilingual"]["role"]
-        elif any(keyword in prompt_lower for keyword in vision_keywords):
-            return MODELS["vision_expert"]["name"], MODELS["vision_expert"]["role"]
-        else:
-            # Fallback si no se puede consultar el cliente
-            return MODELS["general_smart"]["name"], MODELS["general_smart"]["role"]
-    except Exception as e:
-        logger.error(f"Error en select_best_model: {e}")
-        return MODELS["general_smart"]["name"], MODELS["general_smart"]["role"]
-
-# Información de modelos
-def get_models_info():
-    info = "## 🎯 Modelos Disponibles y sus Especialidades:\n\n"
-    for key, model in MODELS.items():
-        info += f"**{model['role']}**\n"
-        info += f"`{model['name']}` - {model.get('description', '')}\n\n"
-    return info
-
-# Utilidades de imagen
-def encode_image(image_path):
-    try:
-        with open(image_path, "rb") as image_file:
-            return base64.b64encode(image_file.read()).decode('utf-8')
-    except Exception as e:
-        logger.error(f"Error codificando imagen: {e}")
-        return None
-
-def guardar_imagen_local(img, index):
-    try:
-        timestamp = int(time.time())
-        nombre_archivo = f"reve_{timestamp}_{index}.png"
-        ruta_completa = os.path.join(CARPETA_SALIDA, nombre_archivo)
-        img.save(ruta_completa, "PNG")
-        return ruta_completa
-    except Exception as e:
-        logger.error(f"Error guardando imagen: {e}")
+# ===========================
+#   CSS PERSONALIZADO
+# ===========================
+custom_css = """
+.gradio-container {max-width: 900px !important; margin: auto;}
+.model-box {padding: 10px; border-radius: 10px; background: #1d1d1d; margin-bottom: 6px;}
+"""# ===========================
+#   CODIFICAR IMAGEN EN BASE64
+# ===========================
+def encode_image(img):
+    if img is None:
         return None
-
-def llamar_api(prompt, ratio, version, api_key, index):
+    buffer = io.BytesIO()
+    img.save(buffer, format="PNG")
+    return base64.b64encode(buffer.getvalue()).decode()
+
+# ===========================
+#   API CALL SAMBANOVA
+# ===========================
+def call_sambanova(model, messages, images=None):
+    url = f"{BASE_URL}/chat/completions"
+    
     payload = {
-        "prompt": prompt,
-        "aspect_ratio": ratio,
-        "version": version
+        "model": model,
+        "messages": messages,
+        "stream": False
     }
+
+    if images:
+        payload["images"] = images
+
     headers = {
-        "Authorization": f"Bearer {api_key}",
+        "Authorization": f"Bearer {API_KEY}",
         "Content-Type": "application/json"
     }
 
-    try:
-        response = requests.post(API_URL, headers=headers, json=payload, timeout=120)
-        if response.status_code == 200:
-            data = response.json()
-            if "image" in data:
-                img_bytes = base64.b64decode(data["image"])
-                img = Image.open(BytesIO(img_bytes)).convert("RGBA")
-                guardar_imagen_local(img, index)
-                return img, data.get('credits_used', 0), None
-        return None, 0, f"Error {response.status_code}: {response.text}"
-    except Exception as e:
-        logger.error(f"Excepción en llamar_api: {e}")
-        return None, 0, f"Error de conexión: {str(e)}"
-
-def generar_imagenes_batch(prompt, api_key_ui, ratio, version, num_imagenes):
-    api_key = api_key_ui.strip() if api_key_ui else os.getenv("REVE_API_KEY")
-
-    if not api_key:
-        return [], "❌ ¡Necesitas la API Key de ReVE!"
-
-    if not prompt or not prompt.strip():
-        return [], "❌ Escribe un prompt para generar imágenes"
-
-    imagenes_nuevas = []
-    errores = []
-    creditos_totales = 0
-
-    num_imagenes = min(num_imagenes, 8)
-
-    try:
-        with concurrent.futures.ThreadPoolExecutor(max_workers=min(num_imagenes, 4)) as executor:
-            futuros = [
-                executor.submit(llamar_api, prompt.strip(), ratio, version, api_key, i)
-                for i in range(num_imagenes)
+    response = requests.post(url, json=payload, headers=headers)
+    
+    if response.status_code != 200:
+        return f"⚠️ Error en API: {response.status_code}\n{response.text}"
+
+    data = response.json()
+    return data["choices"][0]["message"]["content"]
+
+# ===========================
+#   CHAT PRINCIPAL
+# ===========================
+def chat_logic(user_text, user_image, model_selection, history):
+    selected = MODELS[model_selection]
+    model_name = selected["name"]
+
+    msg = []
+    images_encoded = None
+
+    msg.append({"role": "system", "content": selected["role"]})
+
+    if user_image:
+        images_encoded = [encode_image(user_image)]
+        msg.append({
+            "role": "user",
+            "content": [
+                {"type": "text", "text": user_text or "Describe esta imagen."},
+                {"type": "image", "image": images_encoded[0]}
             ]
-
-            for futuro in concurrent.futures.as_completed(futuros):
-                try:
-                    img, creditos, error = futuro.result(timeout=120)
-                    if img:
-                        imagenes_nuevas.append(img)
-                        creditos_totales += creditos
-                    if error:
-                        errores.append(error)
-                except concurrent.futures.TimeoutError:
-                    errores.append("Timeout en generación")
-    except Exception as e:
-        logger.error(f"Error en generación batch: {e}")
-        errores.append(f"Error del sistema: {str(e)}")
-
-    if imagenes_nuevas:
-        mensaje = f"✅ {len(imagenes_nuevas)} imágenes generadas | Créditos: {creditos_totales}"
-        if errores:
-            mensaje += f" | Errores: {len(errores)}"
-        return imagenes_nuevas, mensaje
+        })
     else:
-        error_msg = "; ".join(errores[:3])
-        return [], f"❌ Error: {error_msg}"
-
-# Lógica de chat
-def chat_logic(message, history, selected_model, api_key_ui, ratio, version, num_imagenes):
-    user_text = message.get("text", "").strip()
-    files = message.get("files", [])
-
-    if not user_text and not files:
-        yield "Por favor, ingresa un texto o sube una imagen."
-        return
-
-    if user_text.lower() in ["/modelos", "/help", "/ayuda"]:
-        yield get_models_info()
-        return
+        msg.append({"role": "user", "content": user_text})
 
-    target_model = ""
-    model_role = ""
-    messages_payload = []
-
-    try:
-        if files:
-            target_model = MODELS["vision_expert"]["name"]
-            model_role = MODELS["vision_expert"]["role"]
-            image_b64 = encode_image(files[0])
-            if not image_b64:
-                yield "❌ Error procesando la imagen."
-                return
-
-            messages_payload = [
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": user_text or "Describe esta imagen en detalle."},
-                        {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{image_b64}"}}
-                    ]
-                }
-            ]
-            yield f"👁️ **Modelo Seleccionado:** `{model_role}`\n*Analizando imagen...*\n\n"
+    reply = call_sambanova(model_name, msg, images_encoded)
 
-        else:
-            if selected_model == "auto":
-                target_model, model_role = select_best_model(user_text)
-            else:
-                # En caso de que selected_model no exista en MODELS, hacer fallback
-                if selected_model not in MODELS:
-                    target_model, model_role = MODELS["general_smart"]["name"], MODELS["general_smart"]["role"]
-                else:
-                    target_model = MODELS[selected_model]["name"]
-                    model_role = MODELS[selected_model]["role"]
-
-            messages_payload = [
-                {"role": "system", "content": f"Eres un asistente especializado en {model_role}. Responde de manera útil y detallada en el mismo idioma del usuario."},
-                {"role": "user", "content": user_text}
-            ]
-
-            yield f"🧠 **Modelo Seleccionado:** `{model_role}`\n*Procesando tu solicitud...*\n\n"
-
-        if not client:
-            yield "❌ Error: Cliente de API no configurado. Verifica tu API Key."
-            return
-
-        stream = client.chat.completions.create(
-            model=target_model,
-            messages=messages_payload,
-            temperature=0.3,
-            top_p=0.9,
-            stream=True
-        )
+    history.append(("🧍 Usuario: " + (user_text or "[Imagen]"), "🤖 Modelo: " + reply))
+    return history, reply
 
-        partial_response = f"**{model_role}**\n\n"
-        for chunk in stream:
-            # Ajuste en la lectura del stream dependiendo del SDK real
-            delta = getattr(chunk.choices[0], "delta", None)
-            content = None
-            if delta:
-                content = getattr(delta, "content", None)
-            else:
-                # Fallback: intentar extraer de 'message' (varía por SDK)
-                content = getattr(chunk.choices[0], "message", {}).get("content") if hasattr(chunk.choices[0], "message") else None
+# ===========================
+#   INTERFAZ
+# ===========================
+def create_ui():
+    with gr.Blocks(css=custom_css) as demo:
 
-            if content:
-                partial_response += content
-                yield partial_response
-
-    except Exception as e:
-        logger.error(f"Error en chat_logic: {e}")
-        yield f"❌ Error: {str(e)}"
-
-# CSS (sin cambios funcionales)
-custom_css = """
-:root {
-    --primary: #ff6b6b;
-    --secondary: #4ecdc4;
-    --dark: #1a1a2e;
-    --accent: #ffd93d;
-}
-.gradio-container { background: linear-gradient(135deg, var(--dark) 0%, #16213e 100%); min-height: 100vh; font-family: 'Segoe UI', system-ui, sans-serif; }
-.dark .chatbot { background: rgba(255,255,255,0.95) !important; border-radius: 15px !important; box-shadow: 0 8px 32px rgba(0,0,0,0.3) !important; backdrop-filter: blur(10px); border: 1px solid rgba(255,255,255,0.2); }
-h1 { background: linear-gradient(45deg, var(--primary), var(--accent)); -webkit-background-clip: text; -webkit-text-fill-color: transparent; background-clip: text; text-align: center; font-size: 2.8em !important; margin-bottom: 5px !important; font-weight: 800 !important; }
-.model-selector { background: rgba(255,255,255,0.1) !important; border-radius: 12px !important; padding: 15px !important; border: 1px solid rgba(255,255,255,0.2) !important; }
-.model-info { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important; border-radius: 12px !important; padding: 20px !important; color: white !important; margin-bottom: 20px !important; }
-.textbox { border-radius: 12px !important; border: 2px solid var(--secondary) !important; background: rgba(255,255,255,0.95) !important; }
-button.primary { background: linear-gradient(45deg, var(--primary), var(--accent)) !important; border: none !important; border-radius: 10px !important; color: #1a1a2e !important; font-weight: 700 !important; transition: all 0.3s ease !important; }
-button.primary:hover { transform: translateY(-2px); box-shadow: 0 6px 20px rgba(255,217,61,0.4) !important; }
-.gallery { border-radius: 12px !important; padding: 15px; background: rgba(255,255,255,0.1) !important; }
-.model-badge { background: linear-gradient(45deg, #4ecdc4, #44a08d) !important; color: white !important; padding: 4px 12px !important; border-radius: 20px !important; font-size: 0.8em !important; font-weight: 600 !important; }
-"""
-
-# Construcción de la interfaz Gradio (modularizada)
-def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
-        gr.Markdown("# 🤖 BATUTO-ART: Ejército de IAs Especializadas")
-        gr.Markdown("### Cada modelo tiene su superpoder. ¡Elige el perfecto para tu tarea!")
-
-        galeria_state = gr.State([])
+        gr.Markdown("# 🤖 Chat avanzado con modelos SambaNova")
 
         with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown(\"\"\"
-                <div class='model-info'>
-                <h3>🎯 Sistema de Modelos Especializados</h3>
-                <p>Cada IA tiene su expertise. El sistema automático elige la mejor para tu tarea, 
-                o puedes seleccionar manualmente el especialista que necesitas.</p>
-                </div>
-                \"\"\")
-
-        with gr.Tab("💬 Chat Inteligente"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### 🎛️ Configuración del Modelo")
-
-                    model_selector = gr.Dropdown(
-                        choices=["auto"] + list(MODELS.keys()),
-                        value="auto",
-                        label="🔧 Selecciona el Modelo",
-                        info="'Auto' elige automáticamente el mejor modelo",
-                        elem_classes="model-selector"
-                    )
-
-                    def update_model_info(selected_model):
-                        if selected_model == "auto":
-                            return "🤖 **Modo Automático:** El sistema elegirá el mejor modelo para tu tarea"
-                        else:
-                            model = MODELS[selected_model]
-                            return f\"🎯 **{model['role']}**\\n\\n{model.get('description','')}\"
-
-                    model_info = gr.Markdown(value=update_model_info("auto"), label="Información del Modelo")
-                    model_selector.change(update_model_info, inputs=[model_selector], outputs=[model_info])
-
-                    gr.Markdown("### 💡 Comandos Especiales")
-                    gr.Markdown("- Escribe `/modelos` para ver todos los modelos disponibles")
-                    gr.Markdown("- Escribe `/help` para ayuda")
-
-                with gr.Column(scale=3):
-                    chatbot = gr.ChatInterface(
-                        fn=lambda message, history: chat_logic(message, history, "auto", None, "1:1", "latest", 1),
-                        multimodal=True,
-                        textbox=gr.MultimodalTextbox(
-                            file_types=["image"],
-                            placeholder="Escribe tu mensaje o sube una imagen...",
-                            show_label=False,
-                        ),
-                        title="Chat con Especialistas de IA",
-                        examples=[
-                            ["¿Puedes revisar este código Python?"],
-                            ["Explícame la teoría de la relatividad"],
-                            ["Traduce 'hola' al japonés"],
-                            ["Analiza esta imagen y descríbemela"]
-                        ]
-                    )
+            model_selection = gr.Dropdown(
+                choices=list(MODELS.keys()),
+                value="general_fast",
+                label="Modelo"
+            )
 
-        with gr.Tab("🎨 Generar Imágenes"):
-            with gr.Row():
-                with gr.Column(scale=1):
-                    gr.Markdown("### ⚙️ Configuración de Imágenes")
+        user_text = gr.Textbox(label="Escribe tu mensaje")
+        user_image = gr.Image(label="Sube una imagen (opcional)")
 
-                    api_key_input = gr.Textbox(label="🔑 API Key de ReVE", placeholder="sk-...", type="password")
-                    prompt = gr.Textbox(label="Prompt", placeholder="Describe la imagen que quieres generar...", lines=3)
-                    with gr.Row():
-                        limpiar_btn = gr.Button("🧹 Limpiar", size="sm")
-                        generar_btn = gr.Button("🚀 Generar Imágenes", variant="primary")
-                    with gr.Row():
-                        ratio = gr.Dropdown(choices=["16:9", "9:16", "3:2", "2:3", "4:3", "3:4", "1:1"], value="1:1", label="Relación de aspecto")
-                        num_imagenes = gr.Slider(1, 4, step=1, value=1, label="Número de imágenes")
-                    version = gr.Dropdown(choices=["latest", "reve-create@20250915"], value="latest", label="Versión del modelo")
+        chatbox = gr.Chatbot(label="Conversación")
+        output_text = gr.Textbox(label="Respuesta del modelo")
 
-                with gr.Column(scale=2):
-                    gr.Markdown("### 🖼️ Resultados")
-                    salida_galeria = gr.Gallery(label="Imágenes Generadas", columns=2, height=400)
-                    mensaje_salida = gr.Markdown()
-                    gr.Markdown("### 📚 Historial de Sesión")
-                    galeria_historial = gr.Gallery(label="Todas las imágenes generadas", columns=4, height=300)
+        send_btn = gr.Button("Enviar")
 
-        limpiar_btn.click(lambda: "", outputs=prompt)
-        generar_btn.click(fn=generar_imagenes_batch, inputs=[prompt, api_key_input, ratio, version, num_imagenes], outputs=[salida_galeria, mensaje_salida]).then(
-            lambda nuevas, historial: historial + nuevas if historial else nuevas,
-            inputs=[salida_galeria, galeria_state],
-            outputs=[galeria_historial, galeria_state]
+        send_btn.click(
+            chat_logic,
+            inputs=[user_text, user_image, model_selection, chatbox],
+            outputs=[chatbox, output_text]
         )
 
-        return demo
+    return demo# ===========================
+#   LANZAR INTERFAZ
+# ===========================
+demo = create_ui()
 
 if __name__ == "__main__":
-    demo = create_interface()
-    demo.launch(server_name="0.0.0.0" if os.getenv("DEPLOY") else "127.0.0.1", share=False)
+    demo.launch()