Update modules/interface.py

modules/interface.py

@@ -12,65 +12,47 @@ from modules.utils.chat_utils import (
 
 PLACEHOLDER = "Escribe lo que necesites..."
 
-// ---------------- JAVASCRIPT PARA LA NÉBULA/RED NEURONAL CIRCULAR AZUL FOTURISTA ----------------
-// Reemplaza la sección NEBULA_JS anterior con este nuevo código.
-
+# ---------------- JAVASCRIPT: NÉBULA CIRCULAR AZUL ----------------
 NEBULA_JS = """
 function createCircularNebula() {
     const canvas = document.getElementById('nebulaCanvas');
     if (!canvas) return;
     const ctx = canvas.getContext('2d');
     let particles = [];
-    let animationFrameId;
     
-    // Parámetros de la forma circular
-    const NUM_PARTICLES = 120; // Más partículas para un anillo más denso
-    const INNER_RADIUS_PERCENT = 0.35; // Radio interior del anillo
-    const OUTER_RADIUS_PERCENT = 0.50; // Radio exterior del anillo
-    const CONNECTION_DISTANCE = 110;
+    const NUM_PARTICLES = 100;
+    const CONNECTION_DISTANCE = 90;
 
     function resize() {
-        // Asegurar que el canvas tenga un tamaño para la corona circular
         canvas.width = canvas.offsetWidth;
         canvas.height = canvas.offsetHeight;
-        if (particles.length > 0) initParticles(); // Reinicializar si cambia el tamaño
+        initParticles();
     }
     window.addEventListener('resize', resize);
-    resize();
-
+    
     class Particle {
-        constructor(angle, currentRadius) {
+        constructor(angle, radius) {
             this.angle = angle;
-            this.baseRadius = currentRadius;
-            this.angleSpeed = (Math.random() - 0.5) * 0.003; // Velocidad angular lenta
-            this.radiusOscillation = Math.random() * 5 + 2; // Oscilación radial pequeña
-            this.radiusFreq = Math.random() * 0.05 + 0.01;
+            this.baseRadius = radius;
+            this.speed = (Math.random() - 0.5) * 0.005;
+            this.oscillation = Math.random() * 10;
             this.time = Math.random() * 100;
-            
-            // Posición inicial
-            this.updatePosition();
+            this.update();
         }
-
-        updatePosition() {
-            this.time += 1;
-            // Un poco de movimiento orbital y oscilación radial
-            const osc = Math.sin(this.time * this.radiusFreq) * this.radiusOscillation;
-            const r = this.baseRadius + osc;
-            
-            this.x = canvas.width / 2 + r * Math.cos(this.angle);
-            this.y = canvas.height / 2 + r * Math.sin(this.angle);
-            
-            this.angle += this.angleSpeed;
+        update() {
+            this.time += 0.02;
+            const r = this.baseRadius + Math.sin(this.time) * this.oscillation;
+            this.x = canvas.width / 2 + Math.cos(this.angle) * r;
+            this.y = canvas.height / 2 + Math.sin(this.angle) * r;
+            this.angle += this.speed;
         }
-
         draw() {
-            ctx.fillStyle = 'rgba(0, 210, 255, 0.9)'; // Azul Neón Intenso
+            ctx.fillStyle = 'rgba(0, 210, 255, 0.8)';
             ctx.beginPath();
-            // Dibujar un pequeño triángulo
-            const size = 2.5;
-            ctx.moveTo(this.x, this.y - size);
-            ctx.lineTo(this.x + size, this.y + size);
-            ctx.lineTo(this.x - size, this.y + size);
+            const s = 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();
         }
@@ -78,192 +60,134 @@ function createCircularNebula() {
 
     function initParticles() {
         particles = [];
-        const canvasMinDim = Math.min(canvas.width, canvas.height);
-        const innerRadius = canvasMinDim * INNER_RADIUS_PERCENT;
-        const outerRadius = canvasMinDim * OUTER_RADIUS_PERCENT;
-
+        const minDim = Math.min(canvas.width, canvas.height) / 2;
         for (let i = 0; i < NUM_PARTICLES; i++) {
-            const angle = (i / NUM_PARTICLES) * Math.PI * 2;
-            const currentRadius = innerRadius + Math.random() * (outerRadius - innerRadius);
-            particles.push(new Particle(angle, currentRadius));
+            const angle = Math.random() * Math.PI * 2;
+            const r = minDim * (0.5 + Math.random() * 0.3);
+            particles.push(new Particle(angle, r));
         }
     }
 
-    initParticles();
-
     function animate() {
         ctx.clearRect(0, 0, canvas.width, canvas.height);
-        ctx.strokeStyle = 'rgba(50, 150, 255, 0.2)'; // Enlaces azules más sutiles
+        ctx.strokeStyle = 'rgba(0, 150, 255, 0.15)';
         ctx.lineWidth = 0.8;
-
         particles.forEach((p, i) => {
-            p.updatePosition();
+            p.update();
             p.draw();
-            
             for (let j = i + 1; j < particles.length; j++) {
-                const p2 = particles[j];
-                const dist = Math.hypot(p.x - p2.x, p.y - p2.y);
-                if (dist < CONNECTION_DISTANCE) {
+                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(p2.x, p2.y);
+                    ctx.lineTo(particles[j].x, particles[j].y);
                     ctx.stroke();
                 }
             }
         });
-        animationFrameId = requestAnimationFrame(animate);
-    }
-    
-    // Cancelar la animación anterior si existe antes de empezar una nueva
-    if (window.nebulaAnimationFrameId) {
-        cancelAnimationFrame(window.nebulaAnimationFrameId);
+        requestAnimationFrame(animate);
     }
-    window.nebulaAnimationFrameId = animationFrameId;
-
+    resize();
     animate();
 }
-
-// Ejecutar con un pequeño retraso para asegurar que Gradio haya montado el canvas
 setTimeout(createCircularNebula, 1000);
 """
 
-# ---------------- VOZ A TEXTO ----------------
+# ---------------- FUNCIONES DE SOPORTE (SIN CAMBIOS) ----------------
 def speech_to_text(audio):
-    if audio is None:
-        return ""
-    try:
-        return transcribe_audio_file(audio)
+    if audio is None: return ""
+    try: return transcribe_audio_file(audio)
     except Exception as e:
         print("Error STT:", e)
         return ""
 
-# ---------------- RESUMEN PARA VOZ ----------------
 def summarize_for_voice(text, max_chars=250):
-    if not text:
-        return ""
+    if not text: return ""
     text = str(text).strip()
-    if len(text) <= max_chars:
-        return text
+    if len(text) <= max_chars: return text
     summary = text[:max_chars]
-    if "." in summary:
-        summary = summary.rsplit(".", 1)[0] + "."
-    else:
-        summary = summary.rsplit(" ", 1)[0]
+    if "." in summary: summary = summary.rsplit(".", 1)[0] + "."
+    else: summary = summary.rsplit(" ", 1)[0]
     return summary + " ..."
 
-# ---------------- PROCESAR GENERATOR ----------------
 def process_chat_result(result):
     final_response = []
     try:
         if hasattr(result, "__iter__") and not isinstance(result, list):
-            for update in result:
-                final_response = update
-        else:
-            final_response = result
-    except Exception as e:
-        print("Error generator:", e)
-    if final_response is None:
-        final_response = []
-    if not isinstance(final_response, list):
-        final_response = [["", str(final_response)]]
+            for update in result: final_response = update
+        else: final_response = result
+    except Exception as e: print("Error generator:", e)
+    if final_response is None: final_response = []
+    if not isinstance(final_response, list): final_response = [["", str(final_response)]]
     return final_response
 
-# ---------------- NORMALIZAR CHAT ----------------
 def normalize_chat_format(chat_data):
-    if not isinstance(chat_data, list):
-        return [["", str(chat_data)]]
+    if not isinstance(chat_data, list): return [["", str(chat_data)]]
     normalized = []
     for item in chat_data:
-        if isinstance(item, list) and len(item) == 2:
-            normalized.append(item)
-        elif isinstance(item, tuple) and len(item) == 2:
-            normalized.append([item[0], item[1]])
-        else:
-            normalized.append(["", str(item)])
+        if isinstance(item, list) and len(item) == 2: normalized.append(item)
+        elif isinstance(item, tuple) and len(item) == 2: normalized.append([item[0], item[1]])
+        else: normalized.append(["", str(item)])
     return normalized
 
-# ---------------- ENVÍO TEXTO ----------------
 def handle_text_chat(chat_history, user_text, chat_function):
-    if chat_history is None:
-        chat_history = []
+    if chat_history is None: chat_history = []
     result = chat_function(chat_history, user_text)
     final_response = process_chat_result(result)
     return normalize_chat_format(final_response)
 
-# ---------------- FUNCIÓN CENTRAL VOZ ----------------
 def voice_chat(chat_history, audio, mode, uploaded_document=None):
-    if chat_history is None:
-        chat_history = []
-    if audio is None:
-        return chat_history, None
-    try:
-        user_text = transcribe_audio_file(audio)
-    except Exception as e:
-        print("Error audio:", e)
-        return chat_history + [["", "❌ Error al transcribir audio"]], None
-    if not user_text:
-        return chat_history + [["", "⚠️ No se pudo entender el audio"]], None
-
-    if mode == "productividad":
-        result = productivity_chat(chat_history, user_text)
-    elif mode == "web":
-        result = browser_chat(chat_history, user_text)
-    elif mode == "cientifico":
-        result = scientist_chat(chat_history, user_text)
-    elif mode == "pdf":
-        result = document_chat(chat_history, user_text, uploaded_document)
-    else:
-        result = regular_chat(chat_history, user_text)
+    if chat_history is None: chat_history = []
+    if audio is None: return chat_history, None
+    try: user_text = transcribe_audio_file(audio)
+    except Exception as e: return chat_history + [["", "❌ Error"]], None
+    
+    if mode == "productividad": result = productivity_chat(chat_history, user_text)
+    elif mode == "web": result = browser_chat(chat_history, user_text)
+    elif mode == "cientifico": result = scientist_chat(chat_history, user_text)
+    elif mode == "pdf": result = document_chat(chat_history, user_text, uploaded_document)
+    else: result = regular_chat(chat_history, user_text)
 
-    final_response = process_chat_result(result)
-    final_response = normalize_chat_format(final_response)
+    final_response = normalize_chat_format(process_chat_result(result))
     audio_path = None
     try:
-        last_msg = final_response[-1][1]
-        voice_text = summarize_for_voice(last_msg)
+        voice_text = summarize_for_voice(final_response[-1][1])
         audio_path = speak(voice_text)
-    except Exception as e:
-        print("Error TTS:", e)
+    except: pass
     return final_response, audio_path
 
-# ---------------- CSS ----------------
+# ---------------- CSS MEJORADO (CENTRADOS) ----------------
 CUSTOM_CSS = """
-body {
-    background: #0a0f1e;
-    color: white;
-}
-.chatbot {
-    height: 500px !important;
+body { background: #0a0f1e; color: white; }
+.chatbot { height: 500px !important; }
+.nebula-container-outer {
+    display: flex;
+    justify-content: center;
+    width: 100%;
+    margin-bottom: 20px;
 }
 .nebula-wrapper {
     background: rgba(0, 0, 0, 0.4);
-    border-radius: 15px;
-    border: 1px solid rgba(0, 255, 150, 0.2);
+    border-radius: 50%; /* Forma circular para el fondo también */
+    border: 1px solid rgba(0, 210, 255, 0.3);
     overflow: hidden;
+    width: 300px; /* Tamaño del recuadro controlado */
+    height: 300px;
     position: relative;
-    width: 100%;
-    height: 250px;
-    margin-bottom: 20px;
-}
-#nebulaCanvas {
-    display: block;
-    width: 100%;
-    height: 100%;
+    box-shadow: 0 0 20px rgba(0, 210, 255, 0.1);
 }
+#nebulaCanvas { width: 100%; height: 100%; display: block; }
 """
 
-# ---------------- TAB REUTILIZABLE ----------------
 def create_chat_tab(chat_function, mode_name):
     chatbot = gr.Chatbot(height=500)
     audio_player = gr.Audio(label="🔊 Respuesta por voz", autoplay=True)
     text_input = gr.Textbox(placeholder=PLACEHOLDER)
     mic = gr.Audio(sources=["microphone"], type="filepath")
-
     with gr.Row():
         text_button = gr.Button("Enviar")
         voice_button = gr.Button("🎤 Voz")
         clear_button = gr.Button("Limpiar")
-
     text_button.click(lambda h, t: handle_text_chat(h, t, chat_function), inputs=[chatbot, text_input], outputs=chatbot)
     voice_button.click(lambda h, a: voice_chat(h, a, mode_name), inputs=[chatbot, mic], outputs=[chatbot, audio_player])
     clear_button.click(lambda: ([], None), outputs=[chatbot, audio_player])
@@ -279,42 +203,27 @@ with gr.Blocks(css=CUSTOM_CSS, head=f"<script>{NEBULA_JS}</script>") as assistan
             gr.Markdown("# 🤖 Asistente Virtual CVision")
             gr.Markdown("### Sistema multimodal con voz")
 
-    # CONTENEDOR DE LA ANIMACIÓN NÉBULA
+    # ANIMACIÓN NÉBULA CENTRADA
     gr.HTML("""
-        <div class="nebula-wrapper">
-            <canvas id="nebulaCanvas"></canvas>
+        <div class="nebula-container-outer">
+            <div class="nebula-wrapper">
+                <canvas id="nebulaCanvas"></canvas>
+            </div>
         </div>
     """)
 
-    # GENERAL
-    with gr.Tab("💬 General"):
-        create_chat_tab(regular_chat, "general")
-
-    # WEB
-    with gr.Tab("🌐 Web"):
-        create_chat_tab(browser_chat, "web")
-
-    # PRODUCTIVIDAD
-    with gr.Tab("📈 Productividad"):
-        create_chat_tab(productivity_chat, "productividad")
-
-    # CIENTÍFICO
-    with gr.Tab("🔬 Científico"):
-        create_chat_tab(scientist_chat, "cientifico")
-
-    # PDF
+    with gr.Tab("💬 General"): create_chat_tab(regular_chat, "general")
+    with gr.Tab("🌐 Web"): create_chat_tab(browser_chat, "web")
+    with gr.Tab("📈 Productividad"): create_chat_tab(productivity_chat, "productividad")
+    with gr.Tab("🔬 Científico"): create_chat_tab(scientist_chat, "cientifico")
     with gr.Tab("📄 Chat PDF"):
         chatbot_pdf = gr.Chatbot(height=500)
         audio_pdf = gr.Audio(label="🔊 Respuesta PDF", autoplay=True)
         uploaded_document = gr.File(file_types=[".pdf"], label="Sube tu PDF")
         text_pdf = gr.Textbox(placeholder=PLACEHOLDER)
         mic_pdf = gr.Audio(sources=["microphone"], type="filepath")
-
         with gr.Row():
-            btn_text = gr.Button("Enviar")
-            btn_voice = gr.Button("🎤 Voz")
-            btn_clear = gr.Button("Limpiar")
-
+            btn_text = gr.Button("Enviar"); btn_voice = gr.Button("🎤 Voz"); btn_clear = gr.Button("Limpiar")
         btn_text.click(lambda h, t, f: handle_text_chat(h, t, lambda hh, tt: document_chat(hh, tt, f)), inputs=[chatbot_pdf, text_pdf, uploaded_document], outputs=chatbot_pdf)
         btn_voice.click(lambda h, a, f: voice_chat(h, a, "pdf", f), inputs=[chatbot_pdf, mic_pdf, uploaded_document], outputs=[chatbot_pdf, audio_pdf])
         btn_clear.click(lambda: ([], None), outputs=[chatbot_pdf, audio_pdf])