Update modules/discourse/discourse_live_interface.py

modules/discourse/discourse_live_interface.py

@@ -32,10 +32,9 @@ def fig_to_bytes(fig):
         return None
 
 #################################################################################################
-
 def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
     """
-    Interfaz para el análisis del discurso en vivo
+    Interfaz para el análisis del discurso en vivo con layout mejorado
     """
     try:
         if 'discourse_live_state' not in st.session_state:
@@ -47,36 +46,39 @@ def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
                 'text_changed': False
             }
 
-        # Crear columnas con proporción 1:3
-        input_col, result_col = st.columns([1, 3])
+        # Título
+        st.subheader(discourse_t.get('enter_text', 'Ingrese sus textos'))
 
-        # Columna izquierda: Entrada de textos
-        with input_col:
-            st.subheader(discourse_t.get('enter_text', 'Ingrese sus textos'))
-            
-            # Primer área de texto
+        # Área de entrada de textos en dos columnas
+        text_col1, text_col2 = st.columns(2)
+
+        # Texto 1
+        with text_col1:
             st.markdown("**Texto 1 (Patrón)**")
             text_input1 = st.text_area(
                 "Texto 1",
-                height=250,
+                height=200,
                 key="discourse_live_text1",
                 value=st.session_state.discourse_live_state.get('current_text1', ''),
                 label_visibility="collapsed"
             )
             st.session_state.discourse_live_state['current_text1'] = text_input1
 
-            # Segundo área de texto
+        # Texto 2
+        with text_col2:
             st.markdown("**Texto 2 (Comparación)**")
             text_input2 = st.text_area(
                 "Texto 2",
-                height=250,
+                height=200,
                 key="discourse_live_text2",
                 value=st.session_state.discourse_live_state.get('current_text2', ''),
                 label_visibility="collapsed"
             )
             st.session_state.discourse_live_state['current_text2'] = text_input2
 
-            # Botón de análisis
+        # Botón de análisis centrado
+        col1, col2, col3 = st.columns([1,2,1])
+        with col1:
             analyze_button = st.button(
                 discourse_t.get('analyze_button', 'Analizar'),
                 key="discourse_live_analyze",
@@ -86,59 +88,64 @@ def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
                 use_container_width=True
             )
 
-            if analyze_button and text_input1 and text_input2:
-                try:
-                    with st.spinner(discourse_t.get('processing', 'Procesando...')):
-                        result = perform_discourse_analysis(
+        # Proceso y visualización de resultados
+        if analyze_button and text_input1 and text_input2:
+            try:
+                with st.spinner(discourse_t.get('processing', 'Procesando...')):
+                    result = perform_discourse_analysis(
+                        text_input1,
+                        text_input2,
+                        nlp_models[lang_code],
+                        lang_code
+                    )
+
+                    if result['success']:
+                        # Procesar ambos gráficos
+                        for graph_key in ['graph1', 'graph2']:
+                            if graph_key in result and result[graph_key] is not None:
+                                bytes_key = f'{graph_key}_bytes'
+                                graph_bytes = fig_to_bytes(result[graph_key])
+                                if graph_bytes:
+                                    result[bytes_key] = graph_bytes
+                                plt.close(result[graph_key])
+
+                        st.session_state.discourse_live_state['last_result'] = result
+                        st.session_state.discourse_live_state['analysis_count'] += 1
+                        
+                        store_student_discourse_result(
+                            st.session_state.username,
                             text_input1,
                             text_input2,
-                            nlp_models[lang_code],
-                            lang_code
+                            result
                         )
 
-                        if result['success']:
-                            # Procesar ambos gráficos
-                            for graph_key in ['graph1', 'graph2']:
-                                if graph_key in result and result[graph_key] is not None:
-                                    bytes_key = f'{graph_key}_bytes'
-                                    graph_bytes = fig_to_bytes(result[graph_key])
-                                    if graph_bytes:
-                                        result[bytes_key] = graph_bytes
-                                    plt.close(result[graph_key])
-
-                            st.session_state.discourse_live_state['last_result'] = result
-                            st.session_state.discourse_live_state['analysis_count'] += 1
-                            
-                            store_student_discourse_result(
-                                st.session_state.username,
-                                text_input1,
-                                text_input2,
-                                result
-                            )
-                        else:
-                            st.error(result.get('message', 'Error en el análisis'))
-
-                except Exception as e:
-                    logger.error(f"Error en análisis: {str(e)}")
-                    st.error(discourse_t.get('error_processing', f'Error al procesar el texto: {str(e)}'))
-
-        # Columna derecha: Visualización de resultados
-        with result_col:
-            st.subheader(discourse_t.get('live_results', 'Resultados en vivo'))
-
-            if 'last_result' in st.session_state.discourse_live_state and \
-               st.session_state.discourse_live_state['last_result'] is not None:
-                
-                result = st.session_state.discourse_live_state['last_result']
-                if all(key in result for key in ['graph1', 'graph2']):
-                    display_discourse_results(result, lang_code, discourse_t)
-                else:
-                    logger.error(f"Faltan gráficos en el resultado: {list(result.keys())}")
-                    st.error(discourse_t.get('missing_graphs', 'Error: No se pudieron generar todos los gráficos'))
-            else:
-                st.info(discourse_t.get('initial_message', 
-                    'Ingrese los textos y presione Analizar para ver los resultados.'))
+                        # Mostrar resultados
+                        st.markdown("---")
+                        st.subheader(discourse_t.get('results_title', 'Resultados del Análisis'))
+                        display_discourse_results(result, lang_code, discourse_t)
+
+                    else:
+                        st.error(result.get('message', 'Error en el análisis'))
+
+            except Exception as e:
+                logger.error(f"Error en análisis: {str(e)}")
+                st.error(discourse_t.get('error_processing', f'Error al procesar el texto: {str(e)}'))
+
+        # Mostrar resultados previos si existen
+        elif 'last_result' in st.session_state.discourse_live_state and \
+             st.session_state.discourse_live_state['last_result'] is not None:
+            
+            st.markdown("---")
+            st.subheader(discourse_t.get('previous_results', 'Resultados del Análisis Anterior'))
+            display_discourse_results(
+                st.session_state.discourse_live_state['last_result'],
+                lang_code,
+                discourse_t
+            )
 
     except Exception as e:
         logger.error(f"Error general en interfaz del discurso en vivo: {str(e)}")
-        st.error(discourse_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+        st.error(discourse_t.get('general_error', "Se produjo un error. Por favor, intente de nuevo."))
+
+
+