Update modules/interface.py

modules/interface.py

@@ -1,6 +1,6 @@
 import gradio as gr
 import re
-import time
+
 from modules.listen import transcribe_audio_file
 from modules.talker.talk import speak
 
@@ -12,52 +12,30 @@ from modules.utils.chat_utils import (
     document_chat
 )
 
-# ---------------- CONFIGURACIÓN Y ESTILOS ----------------
 PLACEHOLDER = "Escribe lo que necesites..."
 
-CUSTOM_CSS = """
-body { background: #0a0f1e; color: white; }
-.chatbot { height: 500px !important; overflow-y: auto; }
-/* Burbujas estilo WhatsApp */
-.chatbot .message.user {
-    background-color: #005a53 !important;
-    border-radius: 15px 15px 0 15px !important;
-    margin-left: 20% !important;
-}
-.chatbot .message.bot {
-    background-color: #1e2736 !important;
-    border-radius: 15px 15px 15px 0 !important;
-    border: 1px solid rgba(0, 210, 255, 0.2);
-    margin-right: 20% !important;
-}
-.nebula-container-outer { display: flex; justify-content: center; width: 100%; margin-bottom: 20px; }
-.nebula-wrapper {
-    background: radial-gradient(circle, rgba(0,210,255,0.05) 0%, rgba(0,0,0,0.6) 100%);
-    border-radius: 50%; border: 2px solid rgba(0, 210, 255, 0.4);
-    width: 300px; height: 300px; overflow: hidden; position: relative;
-}
-#nebulaCanvas { width: 100%; height: 100%; display: block; }
-"""
-
-# ---------------- JAVASCRIPT: NÉBULA ----------------
-NEBULA_JS = """
+# ---------------- NEBULA (TU ORIGINAL COMPLETA) ----------------
+NEBULA_JS = """<script>
 function createCircularNebula() {
     const canvas = document.getElementById('nebulaCanvas');
     if (!canvas) return;
     const ctx = canvas.getContext('2d');
     let particles = [];
+
     const NUM_PARTICLES = 110;
     const CONNECTION_DISTANCE = 100;
 
     function resize() {
-        canvas.width = canvas.offsetWidth; canvas.height = canvas.offsetHeight;
+        canvas.width = canvas.offsetWidth;
+        canvas.height = canvas.offsetHeight;
         initParticles();
     }
     window.addEventListener('resize', resize);
-    
+
     class Particle {
         constructor(angle, radius) {
-            this.angle = angle; this.baseRadius = radius;
+            this.angle = angle;
+            this.baseRadius = radius;
             this.speed = (Math.random() - 0.5) * 0.004;
             this.oscillation = Math.random() * 12;
             this.time = Math.random() * 100;
@@ -71,12 +49,17 @@ function createCircularNebula() {
             this.angle += this.speed;
         }
         draw() {
-            ctx.shadowBlur = 8; ctx.shadowColor = 'rgba(0, 210, 255, 0.8)';
+            ctx.shadowBlur = 8;
+            ctx.shadowColor = 'rgba(0, 210, 255, 0.8)';
             ctx.fillStyle = 'rgba(0, 210, 255, 0.9)';
             ctx.beginPath();
-            const s = 2.2; ctx.moveTo(this.x, this.y - s);
-            ctx.lineTo(this.x + s, this.y + s); ctx.lineTo(this.x - s, this.y + s);
-            ctx.closePath(); ctx.fill(); ctx.shadowBlur = 0;
+            const s = 2.2;
+            ctx.moveTo(this.x, this.y - s);
+            ctx.lineTo(this.x + s, this.y + s);
+            ctx.lineTo(this.x - s, this.y + s);
+            ctx.closePath();
+            ctx.fill();
+            ctx.shadowBlur = 0;
         }
     }
 
@@ -90,153 +73,219 @@ function createCircularNebula() {
         }
     }
 
+    function drawCenterLogo() {
+        const centerX = canvas.width / 2;
+        const centerY = canvas.height / 2;
+
+        const gradient = ctx.createRadialGradient(centerX, centerY, 0, centerX, centerY, 80);
+        gradient.addColorStop(0, 'rgba(0, 210, 255, 0.2)');
+        gradient.addColorStop(1, 'rgba(0, 210, 255, 0)');
+        ctx.fillStyle = gradient;
+        ctx.beginPath();
+        ctx.arc(centerX, centerY, 80, 0, Math.PI * 2);
+        ctx.fill();
+
+        ctx.font = "bold 32px 'Segoe UI'";
+        ctx.textAlign = "center";
+        ctx.textBaseline = "middle";
+        ctx.shadowBlur = 15;
+        ctx.shadowColor = 'rgba(0, 210, 255, 0.9)';
+
+        const textGradient = ctx.createLinearGradient(centerX - 50, 0, centerX + 50, 0);
+        textGradient.addColorStop(0, '#ffffff');
+        textGradient.addColorStop(1, '#00d2ff');
+
+        ctx.fillStyle = textGradient;
+        ctx.fillText("CVision", centerX, centerY);
+        ctx.shadowBlur = 0;
+    }
+
     function animate() {
         ctx.clearRect(0, 0, canvas.width, canvas.height);
-        ctx.strokeStyle = 'rgba(0, 150, 255, 0.12)'; ctx.lineWidth = 0.7;
+
+        ctx.strokeStyle = 'rgba(0, 150, 255, 0.12)';
+        ctx.lineWidth = 0.7;
+
         for (let i = 0; i < particles.length; i++) {
-            const p = particles[i]; p.update(); p.draw();
+            const p = particles[i];
+            p.update();
+            p.draw();
             for (let j = i + 1; j < particles.length; j++) {
                 const d = Math.hypot(p.x - particles[j].x, p.y - particles[j].y);
                 if (d < CONNECTION_DISTANCE) {
-                    ctx.beginPath(); ctx.moveTo(p.x, p.y);
-                    ctx.lineTo(particles[j].x, particles[j].y); ctx.stroke();
+                    ctx.beginPath();
+                    ctx.moveTo(p.x, p.y);
+                    ctx.lineTo(particles[j].x, particles[j].y);
+                    ctx.stroke();
                 }
             }
         }
+
+        drawCenterLogo();
         requestAnimationFrame(animate);
     }
-    resize(); animate();
+
+    resize();
+    animate();
 }
 setTimeout(createCircularNebula, 1000);
+</script>
 """
 
-# ---------------- LÓGICA DE LIMPIEZA Y PROCESAMIENTO ----------------
-def clean_final_text(text):
-    """Limpia el texto de metadatos, rutas de archivos y basura de código."""
-    if not text: return ""
+# ---------------- LIMPIEZA ----------------
+def clean_text(text):
+    if not text:
+        return ""
     text = str(text)
-    # Eliminar rutas de archivos .mp3
-    text = re.sub(r"'/tmp/.*?\.mp3'", "", text)
-    text = re.sub(r"\(.*?\.mp3\)", "", text)
-    # Limpiar sintaxis de generadores y listas
     text = re.sub(r"<generator object.*?>", "", text)
-    text = text.replace("(['", "").replace("'])", "").replace("['", "").replace("']", "")
-    # Eliminar caracteres especiales sobrantes
-    text = text.strip("[]()', ")
-    return text
+    text = re.sub(r"/tmp/.*?\.mp3", "", text)
+    text = re.sub(r"\[\[.*?\]\]", "", text)
+    return text.strip()
 
-def get_assistant_response(chat_history, user_input, chat_func):
-    """Extrae el contenido real de un generador o lista de LangChain."""
+# 🔥 FIX PRINCIPAL
+def extract_text(result):
     try:
-        response_gen = chat_func(chat_history, user_input)
-        final_text = ""
-        
-        # Si es un generador, iteramos hasta el final para obtener el texto completo
-        if hasattr(response_gen, "__iter__") and not isinstance(response_gen, (list, tuple)):
-            for part in response_gen:
-                if isinstance(part, list) and len(part) > 0:
-                    # Gradio Chatbot suele devolver listas de pares [user, bot]
-                    final_text = part[-1][1] 
-                else:
-                    final_text = str(part)
-        else:
-            # Si ya es una lista o string
-            if isinstance(response_gen, list) and len(response_gen) > 0:
-                final_text = response_gen[-1][1] if isinstance(response_gen[-1], (list, tuple)) else response_gen[-1]
-            else:
-                final_text = str(response_gen)
-        
-        return clean_final_text(final_text)
+        if hasattr(result, "__iter__") and not isinstance(result, list):
+            for step in result:
+                result = step
+
+        if isinstance(result, list) and len(result) > 0:
+            last = result[-1]
+            if isinstance(last, (list, tuple)) and len(last) == 2:
+                return last[1]
+
+        return str(result)
+
     except Exception as e:
-        return f"Error de conexión: {str(e)}"
-
-# ---------------- FUNCIONES DE LA INTERFAZ ----------------
-def chat_wrapper(chat_history, user_text, mode, doc=None):
-    if not user_text: return chat_history, ""
-    
-    # Seleccionar función según pestaña
-    modes = {
-        "general": regular_chat,
-        "web": browser_chat,
-        "productividad": productivity_chat,
-        "cientifico": scientist_chat,
-        "pdf": lambda h, t: document_chat(h, t, doc)
-    }
-    
-    selected_func = modes.get(mode, regular_chat)
-    bot_reply = get_assistant_response(chat_history, user_text, selected_func)
-    
-    # Actualizar historial para burbujas tipo WhatsApp
-    chat_history.append((user_text, bot_reply))
-    return chat_history, ""
-
-def voice_wrapper(chat_history, audio_path, mode, doc=None):
-    if not audio_path: return chat_history, None, ""
-    
-    # Transcripción
-    user_text = transcribe_audio_file(audio_path)
-    if not user_text: return chat_history, None, ""
-    
-    # Obtener respuesta
-    new_history, _ = chat_wrapper(chat_history, user_text, mode, doc)
-    bot_reply = new_history[-1][1]
-    
-    # Generar audio de salida limpio
-    clean_for_speech = bot_reply.replace("*", "").replace("#", "")
-    out_audio = speak(clean_for_speech[:300]) 
-    
-    return new_history, out_audio, user_text
-
-# ---------------- INTERFAZ GRADIO ----------------
-with gr.Blocks(css=CUSTOM_CSS, head=f"<script>{NEBULA_JS}</script>") as assistant:
+        return f"Error: {e}"
+
+# ---------------- CHAT TEXT ----------------
+def handle_text(chat_history, user_text, fn):
+    if chat_history is None:
+        chat_history = []
+
+    if not user_text:
+        return chat_history
+
+    result = fn(chat_history, user_text)
+    response = clean_text(extract_text(result))
+
+    chat_history.append([user_text, response])
+    return chat_history
+
+# ---------------- VOZ ----------------
+def handle_voice(chat_history, audio, mode, file=None):
+    if chat_history is None:
+        chat_history = []
+
+    if audio is None:
+        return chat_history, None
+
+    text = transcribe_audio_file(audio)
+
+    if not text:
+        return chat_history, None
+
+    if mode == "web":
+        fn = browser_chat
+    elif mode == "productividad":
+        fn = productivity_chat
+    elif mode == "cientifico":
+        fn = scientist_chat
+    elif mode == "pdf":
+        fn = lambda h, t: document_chat(h, t, file)
+    else:
+        fn = regular_chat
+
+    result = fn(chat_history, text)
+    response = clean_text(extract_text(result))
+
+    chat_history.append([text, response])
+
+    audio_path = speak(response)
+
+    return chat_history, audio_path
+
+# ---------------- STT ----------------
+def speech_to_text(audio):
+    if audio is None:
+        return ""
+    try:
+        return transcribe_audio_file(audio)
+    except:
+        return ""
+
+# ---------------- CSS ----------------
+CUSTOM_CSS = """
+body { background: #0a0f1e; color: white; }
+.chatbot { height: 500px !important; }
+.nebula-container-outer {
+    display: flex;
+    justify-content: center;
+    margin-bottom: 25px;
+}
+.nebula-wrapper {
+    width: 320px;
+    height: 320px;
+    border-radius: 50%;
+    border: 2px solid rgba(0,210,255,0.4);
+    overflow: hidden;
+}
+"""
+
+# ---------------- TAB ----------------
+def create_tab(fn, mode):
+    chatbot = gr.Chatbot(height=500)
+    audio = gr.Audio(visible=False, autoplay=True)
+
+    text = gr.Textbox(placeholder=PLACEHOLDER)
+    mic = gr.Audio(sources=["microphone"], type="filepath")
+
     with gr.Row():
-        with gr.Column(scale=1): gr.Image("assets/CVision logo.png", width=100, show_label=False)
-        with gr.Column(scale=4): 
-            gr.Markdown("# CVision Intelligence")
-            gr.Markdown("### Sistema Multimodal Corregido v2.0")
-
-    gr.HTML('<div class="nebula-container-outer"><div class="nebula-wrapper"><canvas id="nebulaCanvas"></canvas></div></div>')
-
-    def build_tab(mode_name):
-        chatbot = gr.Chatbot(height=450, bubble_full_width=False)
-        voice_output = gr.Audio(visible=False, autoplay=True)
-        
-        with gr.Row():
-            txt_msg = gr.Textbox(placeholder=PLACEHOLDER, scale=7, show_label=False)
-            btn_send = gr.Button("Enviar", variant="primary", scale=1)
-
-        with gr.Row():
-            audio_input = gr.Audio(sources=["microphone"], type="filepath", scale=4)
-            btn_voice = gr.Button("🎤 Procesar Voz", scale=2)
-            btn_clear = gr.Button("Limpiar", scale=2)
-
-        # Acciones
-        btn_send.click(
-            chat_wrapper, [chatbot, txt_msg, gr.State(mode_name)], [chatbot, txt_msg]
-        )
-        txt_msg.submit(
-            chat_wrapper, [chatbot, txt_msg, gr.State(mode_name)], [chatbot, txt_msg]
-        )
-        btn_voice.click(
-            voice_wrapper, [chatbot, audio_input, gr.State(mode_name)], [chatbot, voice_output, txt_msg]
-        )
-        btn_clear.click(lambda: ([], None, ""), None, [chatbot, voice_output, txt_msg])
-
-    with gr.Tab("💬 General"): build_tab("general")
-    with gr.Tab("🌐 Web"): build_tab("web")
-    with gr.Tab("📈 Productividad"): build_tab("productividad")
-    with gr.Tab("🔬 Científico"): build_tab("cientifico")
-    with gr.Tab("📄 Chat PDF"):
-        chatbot_pdf = gr.Chatbot(height=450, bubble_full_width=False)
-        voice_pdf = gr.Audio(visible=False, autoplay=True)
-        file_pdf = gr.File(label="Sube tu documento PDF", file_types=[".pdf"])
-        txt_pdf = gr.Textbox(placeholder=PLACEHOLDER)
-        with gr.Row():
-            b1 = gr.Button("Enviar", variant="primary"); b2 = gr.Button("🎤 Voz"); b3 = gr.Button("Limpiar")
-        
-        b1.click(chat_wrapper, [chatbot_pdf, txt_pdf, gr.State("pdf"), file_pdf], [chatbot_pdf, txt_pdf])
-        b2.click(voice_wrapper, [chatbot_pdf, gr.Audio(sources=["microphone"], type="filepath"), gr.State("pdf"), file_pdf], [chatbot_pdf, voice_pdf, txt_pdf])
-        b3.click(lambda: ([], None, ""), None, [chatbot_pdf, voice_pdf, txt_pdf])
+        send = gr.Button("Enviar")
+        voice = gr.Button("🎤 Voz")
+        clear = gr.Button("Limpiar")
+
+    send.click(lambda h, t: handle_text(h, t, fn), [chatbot, text], chatbot)
+    voice.click(lambda h, a: handle_voice(h, a, mode), [chatbot, mic], [chatbot, audio])
+    clear.click(lambda: ([], None), outputs=[chatbot, audio])
+
+    mic.change(speech_to_text, mic, text)
+
+# ---------------- APP ----------------
+with gr.Blocks(css=CUSTOM_CSS, head=NEBULA_JS) as assistant:
+
+    gr.Markdown("# 🤖 Asistente CVision")
+
+    gr.HTML("""
+    <div class="nebula-container-outer">
+        <div class="nebula-wrapper">
+            <canvas id="nebulaCanvas"></canvas>
+        </div>
+    </div>
+    """)
+
+    with gr.Tab("💬 General"):
+        create_tab(regular_chat, "general")
+
+    with gr.Tab("🌐 Web"):
+        create_tab(browser_chat, "web")
+
+    with gr.Tab("📈 Productividad"):
+        create_tab(productivity_chat, "productividad")
+
+    with gr.Tab("🔬 Científico"):
+        create_tab(scientist_chat, "cientifico")
+
+    with gr.Tab("📄 PDF"):
+        chatbot = gr.Chatbot()
+        audio = gr.Audio(visible=False, autoplay=True)
+        file = gr.File()
+        text = gr.Textbox()
+
+        btn = gr.Button("Enviar")
+        btn.click(lambda h, t, f: handle_text(h, t, lambda hh, tt: document_chat(hh, tt, f)),
+                  [chatbot, text, file], chatbot)
 
 if __name__ == "__main__":
     assistant.launch()