Update modules/discourse/discourse_live_interface.py

modules/discourse/discourse_live_interface.py

@@ -18,6 +18,8 @@ from ..utils.widget_utils import generate_unique_key
 from ..database.discourse_mongo_db import store_student_discourse_result
 from ..database.chat_mongo_db import store_chat_history, get_chat_history
 
+
+#####################################################################################################
 def fig_to_bytes(fig):
     """Convierte una figura de matplotlib a bytes."""
     try:
@@ -29,70 +31,13 @@ def fig_to_bytes(fig):
         logger.error(f"Error en fig_to_bytes: {str(e)}")
         return None
 
+#################################################################################################
 def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
     """
     Interfaz para el análisis del discurso en vivo
     """
     try:
-        # 1. Inicializar el estado de la sesión
-        if 'discourse_live_state' not in st.session_state:
-            st.session_state.discourse_live_state = {
-                'analysis_count': 0,
-                'current_text1': '',
-                'current_text2': '',
-                'last_result': None,
-                'text_changed': False
-            }
-
-        # 2. Función para manejar cambios en los textos
-        def on_text1_change():
-            current_text = st.session_state.discourse_live_text1
-            st.session_state.discourse_live_state['current_text1'] = current_text
-            st.session_state.discourse_live_state['text_changed'] = True
-
-        def on_text2_change():
-            current_text = st.session_state.discourse_live_text2
-            st.session_state.discourse_live_state['current_text2'] = current_text
-            st.session_state.discourse_live_state['text_changed'] = True
-
-        # 3. Crear columnas con proporción 1:3
-        input_col, result_col = st.columns([1, 3])
-
-        # Columna izquierda: Entrada de textos
-        with input_col:
-            st.subheader(discourse_t.get('enter_text', 'Ingrese sus textos'))
-            
-            # Primer área de texto
-            st.markdown("**Texto 1 (Patrón)**")
-            text_input1 = st.text_area(
-                "Texto 1",
-                height=250,
-                key="discourse_live_text1",
-                value=st.session_state.discourse_live_state.get('current_text1', ''),
-                on_change=on_text1_change,
-                label_visibility="collapsed"
-            )
-
-            # Segundo área de texto
-            st.markdown("**Texto 2 (Comparación)**")
-            text_input2 = st.text_area(
-                "Texto 2",
-                height=250,
-                key="discourse_live_text2",
-                value=st.session_state.discourse_live_state.get('current_text2', ''),
-                on_change=on_text2_change,
-                label_visibility="collapsed"
-            )
-
-            # Botón de análisis
-            analyze_button = st.button(
-                discourse_t.get('analyze_button', 'Analizar'),
-                key="discourse_live_analyze",
-                type="primary",
-                icon="🔍",
-                disabled=not (text_input1 and text_input2),
-                use_container_width=True
-            )
+        # [Código anterior igual hasta el análisis]
 
             if analyze_button and text_input1 and text_input2:
                 try:
@@ -106,31 +51,36 @@ def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
                         )
 
                         if result['success']:
-                            # Convertir gráficos a bytes antes de guardar
-                            if 'graph1' in result:
-                                result['graph1_bytes'] = fig_to_bytes(result['graph1'])
-                            if 'graph2' in result:
-                                result['graph2_bytes'] = fig_to_bytes(result['graph2'])
+                            # Asegurarnos de que ambos gráficos se procesen correctamente
+                            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])  # Cerrar la figura después de convertirla
 
                             st.session_state.discourse_live_state['last_result'] = result
                             st.session_state.discourse_live_state['analysis_count'] += 1
                             st.session_state.discourse_live_state['text_changed'] = False
                             
                             # Guardar en base de datos
-                            store_student_discourse_result(
+                            store_result = store_student_discourse_result(
                                 st.session_state.username,
                                 text_input1,
                                 text_input2,
                                 result
                             )
+                            
+                            if not store_result:
+                                logger.warning("No se pudo guardar el análisis en la base de datos")
                         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', 'Error al procesar el texto'))
+                    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'))
@@ -138,12 +88,14 @@ def display_discourse_live_interface(lang_code, nlp_models, discourse_t):
             if 'last_result' in st.session_state.discourse_live_state and \
                st.session_state.discourse_live_state['last_result'] is not None:
                 
-                # Mostrar resultados usando la misma función que el análisis normal
-                display_discourse_results(
-                    st.session_state.discourse_live_state['last_result'],
-                    lang_code,
-                    discourse_t
-                )
+                result = st.session_state.discourse_live_state['last_result']
+                
+                # Verificar que tenemos ambos gráficos antes de mostrarlos
+                if all(key in result for key in ['graph1', 'graph2', 'graph1_bytes', 'graph2_bytes']):
+                    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'))
 
             elif st.session_state.discourse_live_state.get('text_changed', False):
                 st.info(discourse_t.get('changes_pending', 
@@ -154,4 +106,4 @@ def display_discourse_live_interface(lang_code, nlp_models, 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."))