Update modules/semantic/semantic_live_interface.py

modules/semantic/semantic_live_interface.py

@@ -30,111 +30,150 @@ def display_semantic_live_interface(lang_code, nlp_models, semantic_t):
             st.session_state.semantic_live_state['current_text'] = current_text
             st.session_state.semantic_live_state['text_changed'] = True
 
-        # 3. Área de texto para entrada directa
-        st.subheader(semantic_t.get('enter_text', 'Ingrese su texto'))
-        
-        text_input = st.text_area(
-            semantic_t.get('text_input_label', 'Escriba o pegue su texto aquí'),
-            height=300,
-            key="semantic_live_text",
-            value=st.session_state.semantic_live_state.get('current_text', ''),
-            on_change=on_text_change,
-            label_visibility="collapsed"
-        )
+        # 3. Crear columnas para el diseño (1:3 ratio)
+        input_col, result_col = st.columns([1, 3])
 
-        # 4. Botón de análisis
-        analyze_button = st.button(
-            semantic_t.get('analyze_button', 'Analizar'),
-            key="semantic_live_analyze",
-            type="primary",
-            disabled=not text_input,
-            use_container_width=True
-        )
+        # Columna izquierda: Entrada de texto y botón
+        with input_col:
+            st.subheader(semantic_t.get('enter_text', 'Ingrese su texto'))
+            
+            text_input = st.text_area(
+                semantic_t.get('text_input_label', 'Escriba o pegue su texto aquí'),
+                height=400,  # Altura aumentada
+                key="semantic_live_text",
+                value=st.session_state.semantic_live_state.get('current_text', ''),
+                on_change=on_text_change,
+                label_visibility="collapsed"
+            )
 
-        # 5. Procesar análisis cuando se presiona el botón
-        if analyze_button and text_input:
-            with st.spinner(semantic_t.get('processing', 'Procesando...')):
-                try:
-                    analysis_result = process_semantic_input(
-                        text_input,
-                        lang_code,
-                        nlp_models,
-                        semantic_t
-                    )
+            analyze_button = st.button(
+                semantic_t.get('analyze_button', 'Analizar'),
+                key="semantic_live_analyze",
+                type="primary",
+                disabled=not text_input,
+                use_container_width=True
+            )
 
-                    if analysis_result['success']:
-                        # Guardar resultado en sesión y base de datos
-                        st.session_state.semantic_live_state['last_result'] = analysis_result
-                        st.session_state.semantic_live_state['analysis_count'] += 1
-                        st.session_state.semantic_live_state['text_changed'] = False
-                        
-                        # Guardar en MongoDB (colección live)
-                        store_result = store_student_semantic_live_result(
-                            st.session_state.username,
+            # 4. Procesar análisis cuando se presiona el botón
+            if analyze_button and text_input:
+                with st.spinner(semantic_t.get('processing', 'Procesando...')):
+                    try:
+                        analysis_result = process_semantic_input(
                             text_input,
-                            analysis_result['analysis'],
-                            lang_code
+                            lang_code,
+                            nlp_models,
+                            semantic_t
                         )
-                        
-                        if not store_result:
-                            st.error(semantic_t.get('error_saving', 'Error al guardar el análisis'))
+
+                        if analysis_result['success']:
+                            # Guardar resultado en sesión y base de datos
+                            st.session_state.semantic_live_state['last_result'] = analysis_result
+                            st.session_state.semantic_live_state['analysis_count'] += 1
+                            st.session_state.semantic_live_state['text_changed'] = False
+                            
+                            # Guardar en MongoDB (colección live)
+                            store_result = store_student_semantic_live_result(
+                                st.session_state.username,
+                                text_input,
+                                analysis_result['analysis'],
+                                lang_code
+                            )
+                            
+                            if not store_result:
+                                st.error(semantic_t.get('error_saving', 'Error al guardar el análisis'))
+                            else:
+                                st.success(semantic_t.get('analysis_saved', 'Análisis guardado correctamente'))
+                                st.rerun()  # Forzar actualización para mostrar resultados
                         else:
-                            st.success(semantic_t.get('analysis_saved', 'Análisis guardado correctamente'))
-                    else:
-                        st.error(analysis_result.get('message', 'Error en el análisis'))
+                            st.error(analysis_result.get('message', 'Error en el análisis'))
 
-                except Exception as e:
-                    logger.error(f"Error en análisis: {str(e)}")
-                    st.error(semantic_t.get('error_processing', 'Error al procesar el texto'))
+                    except Exception as e:
+                        logger.error(f"Error en análisis: {str(e)}", exc_info=True)
+                        st.error(semantic_t.get('error_processing', f'Error al procesar el texto: {str(e)}'))
 
-        # 6. Mostrar resultados si existen
-        if 'last_result' in st.session_state.semantic_live_state and \
-           st.session_state.semantic_live_state['last_result'] is not None:
-            
-            analysis = st.session_state.semantic_live_state['last_result']['analysis']
-            
-            if 'key_concepts' in analysis and analysis['key_concepts'] and \
-               'concept_graph' in analysis and analysis['concept_graph'] is not None:
-                
-                # Mostrar conceptos clave
-                st.subheader(semantic_t.get('key_concepts', 'Conceptos Clave'))
-                concepts_html = """
-                <div style="display: flex; flex-wrap: wrap; gap: 8px; margin-bottom: 20px;">
-                """ + ''.join([
-                    f'<div style="background-color: #f0f2f6; border-radius: 5px; padding: 6px 10px; display: inline-flex; align-items: center; gap: 6px;">'
-                    f'<span style="font-weight: bold;">{concept}</span>'
-                    f'<span style="color: #666; font-size: 0.9em;">({freq:.2f})</span></div>'
-                    for concept, freq in analysis['key_concepts']
-                ]) + "</div>"
-                st.markdown(concepts_html, unsafe_allow_html=True)
+        # Columna derecha: Resultados
+        with result_col:
+            if 'last_result' in st.session_state.semantic_live_state and \
+               st.session_state.semantic_live_state['last_result'] is not None:
                 
-                # Mostrar gráfico
-                st.subheader(semantic_t.get('concept_network', 'Red de Conceptos'))
-                st.image(
-                    analysis['concept_graph'],
-                    use_container_width=True
-                )
+                analysis = st.session_state.semantic_live_state['last_result']['analysis']
                 
-                # Botón para consultar con el asistente
-                if st.button("💬 Consultar con Asistente", key="semantic_live_chat_button"):
-                    if 'last_result' not in st.session_state.semantic_live_state:
-                        st.error("Primero complete el análisis semántico")
-                        return
-                        
-                    st.session_state.semantic_agent_data = {
-                        'text': st.session_state.semantic_live_state['current_text'],
-                        'metrics': st.session_state.semantic_live_state['last_result']['analysis'],
-                        'graph_data': st.session_state.semantic_live_state['last_result']['analysis'].get('concept_graph')
+                if 'key_concepts' in analysis and analysis['key_concepts'] and \
+                   'concept_graph' in analysis and analysis['concept_graph'] is not None:
+                    
+                    # Mostrar conceptos clave en formato horizontal
+                    st.subheader(semantic_t.get('key_concepts', 'Conceptos Clave'))
+                    concepts_html = """
+                    <style>
+                    .concept-container {
+                        display: flex;
+                        flex-wrap: wrap;
+                        gap: 8px;
+                        margin-bottom: 20px;
+                        max-width: 100%;
+                        overflow-x: auto;
                     }
-                    st.session_state.semantic_agent_active = True
-                    st.rerun()
-                
-                # Notificación si el agente está activo
-                if st.session_state.get('semantic_agent_active', False):
-                    st.success(semantic_t.get('semantic_agent_ready_message', 'El agente virtual está listo. Abre el chat en la barra lateral.'))
+                    .concept-item {
+                        background-color: #f0f2f6;
+                        border-radius: 5px;
+                        padding: 6px 10px;
+                        display: inline-flex;
+                        align-items: center;
+                        gap: 6px;
+                        white-space: nowrap;
+                    }
+                    .concept-name {
+                        font-weight: bold;
+                    }
+                    .concept-freq {
+                        color: #666;
+                        font-size: 0.9em;
+                    }
+                    </style>
+                    <div class="concept-container">
+                    """ + ''.join([
+                        f'<div class="concept-item"><span class="concept-name">{concept}</span>'
+                        f'<span class="concept-freq">({freq:.2f})</span></div>'
+                        for concept, freq in analysis['key_concepts']
+                    ]) + "</div>"
+                    st.markdown(concepts_html, unsafe_allow_html=True)
+                    
+                    # Mostrar gráfico con controles
+                    st.subheader(semantic_t.get('concept_network', 'Red de Conceptos'))
+                    st.image(
+                        analysis['concept_graph'],
+                        use_container_width=True
+                    )
+                    
+                    # Controles debajo del gráfico
+                    btn_col1, btn_col2 = st.columns([1, 3])
+                    with btn_col1:
+                        if st.button("💬 Consultar con Asistente", key="semantic_live_chat_button"):
+                            st.session_state.semantic_agent_data = {
+                                'text': st.session_state.semantic_live_state['current_text'],
+                                'metrics': analysis,
+                                'graph_data': analysis.get('concept_graph')
+                            }
+                            st.session_state.semantic_agent_active = True
+                            st.rerun()
+                    
+                    # Notificación si el agente está activo
+                    if st.session_state.get('semantic_agent_active', False):
+                        st.success(semantic_t.get('semantic_agent_ready_message', 'El agente virtual está listo. Abre el chat en la barra lateral.'))
+                    
+                    # Información de interpretación
+                    with st.expander("📊 Interpretación del gráfico"):
+                        st.markdown("""
+                            - 🔀 **Flechas**: Dirección de las relaciones entre conceptos
+                            - 🎨 **Colores**: Intensidad indica centralidad del concepto
+                            - ⭕ **Tamaño**: Representa frecuencia del concepto
+                            - ↔️ **Grosor**: Fuerza de la conexión entre conceptos
+                        """)
+                else:
+                    st.info(semantic_t.get('no_results', 'No hay resultados para mostrar'))
             else:
-                st.info(semantic_t.get('no_results', 'No hay resultados para mostrar'))
+                st.info(semantic_t.get('analysis_prompt', 'Realice un análisis para ver los resultados'))
 
     except Exception as e:
-        logger.error(f"Error general en interfaz semántica en vivo: {str(e)}")
+        logger.error(f"Error general en interfaz semántica en vivo: {str(e)}", exc_info=True)
         st.error(semantic_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))