Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -535,15 +535,22 @@ def display_semantic_activities(username: str, t: dict):
 
 
 ###################################################################################################
-
 def display_discourse_activities(username: str, t: dict):
     """
-    Muestra actividades de análisis del discurso (mostrado como 'Análisis comparado de textos' en la UI)
-    con mejor manejo de errores y datos incompletos
+    Versión mejorada de display_discourse_activities que maneja mejor 
+    los datos faltantes y la depuración.
     """
     try:
         logger.info(f"Recuperando análisis del discurso para {username}")
-        analyses = get_student_discourse_analysis(username)
+        
+        # Usar la función mejorada de recuperación
+        analyses = get_student_discourse_analysis_fixed(username)
+        
+        # Información de depuración
+        logger.info(f"Recuperados {len(analyses)} análisis de discurso")
+        for i, analysis in enumerate(analyses):
+            keys = list(analysis.keys())
+            logger.info(f"Análisis {i+1}: claves disponibles = {keys}")
         
         if not analyses:
             logger.info("No se encontraron análisis del discurso")
@@ -554,12 +561,9 @@ def display_discourse_activities(username: str, t: dict):
         
         for i, analysis in enumerate(analyses):
             try:
-                # Usar un ID único para este análisis (usando índice si _id no está disponible)
-                analysis_id = str(analysis.get('_id', f"analysis_{i}"))
-                
                 # Formatear fecha con manejo de errores
                 try:
-                    timestamp = datetime.fromisoformat(analysis['timestamp'].replace('Z', '+00:00'))
+                    timestamp = datetime.fromisoformat(analysis.get('timestamp', '').replace('Z', '+00:00'))
                     formatted_date = timestamp.strftime("%d/%m/%Y %H:%M:%S")
                 except (KeyError, ValueError, TypeError) as e:
                     logger.warning(f"Error formateando fecha: {str(e)}")
@@ -568,149 +572,139 @@ def display_discourse_activities(username: str, t: dict):
                 # Crear título del expander
                 expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
                 
+                # Mostrar más información en el título para facilitar identificación
+                if 'text1' in analysis and analysis['text1']:
+                    text_preview = analysis['text1'][:50] + "..." if len(analysis['text1']) > 50 else analysis['text1']
+                    expander_title += f" | {text_preview}"
+                
                 # Crear expander
                 with st.expander(expander_title, expanded=False):
-                    # Determinar si tenemos datos suficientes para mostrar un análisis útil
-                    has_key_concepts = ('key_concepts1' in analysis and analysis['key_concepts1']) or \
-                                      ('key_concepts2' in analysis and analysis['key_concepts2'])
-                    
-                    has_text = ('text1' in analysis and analysis['text1']) or \
-                               ('text2' in analysis and analysis['text2'])
+                    # Mostrar los datos brutos para depuración (solo durante desarrollo)
+                    st.markdown("**Datos del análisis:**")
+                    # Filtrar keys innecesarias o con datos muy grandes
+                    filtered_data = {k: v for k, v in analysis.items() 
+                                    if k not in ['_id', 'timestamp', 'text1', 'text2'] 
+                                    and not isinstance(v, bytes) 
+                                    and not (isinstance(v, str) and len(v) > 500)}
+                    st.json(filtered_data)
                     
-                    has_graphs = any(analysis.get(k) is not None for k in ['graph1', 'graph2', 'combined_graph'])
+                    # Mostrar textos analizados (si están disponibles)
+                    if 'text1' in analysis and analysis['text1']:
+                        with st.expander("Ver texto analizado", expanded=False):
+                            st.markdown("**Texto analizado:**")
+                            st.text_area("Texto", value=analysis['text1'], height=150, disabled=True)
                     
-                    # Si no hay suficiente información, mostrar mensaje adecuado
-                    if not (has_key_concepts or has_text or has_graphs):
-                        st.warning(t.get('insufficient_data', 'Datos insuficientes para mostrar un análisis completo'))
-                        # Mostrar datos disponibles en formato JSON para depuración (opcional)
-                        # NO usar expander aquí para evitar expanders anidados
-                        st.markdown("**Datos disponibles:**")
-                        st.json({k: v for k, v in analysis.items() 
-                               if k not in ['_id', 'timestamp'] and v is not None})
-                        continue
+                    # Mostrar conceptos clave (si están disponibles)
+                    has_concepts = False
                     
-                    # Mostrar conceptos clave
-                    if has_key_concepts:
+                    # Verificar si hay conceptos y son del formato correcto
+                    if ('key_concepts1' in analysis and analysis['key_concepts1'] and 
+                        isinstance(analysis['key_concepts1'], list)):
+                        has_concepts = True
+                        
+                        # Crear dos columnas para los conceptos
                         col1, col2 = st.columns(2)
                         
+                        # Primera columna: conceptos del texto 1
                         with col1:
                             st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
-                            if 'key_concepts1' in analysis and analysis['key_concepts1']:
-                                try:
-                                    # Intentar diferentes formatos de conceptos clave
-                                    if isinstance(analysis['key_concepts1'], list) and \
-                                       len(analysis['key_concepts1']) > 0:
-                                        # Verificar si es lista de listas (formato esperado)
-                                        if isinstance(analysis['key_concepts1'][0], list) and \
-                                           len(analysis['key_concepts1'][0]) == 2:
-                                            df1 = pd.DataFrame(analysis['key_concepts1'], 
-                                                             columns=['Concepto', 'Relevancia'])
-                                            st.dataframe(df1, use_container_width=True)
-                                        else:
-                                            # Es una lista simple
-                                            st.write(", ".join(str(c) for c in analysis['key_concepts1']))
-                                    else:
-                                        st.write(str(analysis['key_concepts1']))
-                                except Exception as e:
-                                    logger.error(f"Error mostrando conceptos 1: {str(e)}")
-                                    st.error(t.get('error_concepts1', 'Error mostrando conceptos del Texto 1'))
-                            else:
-                                st.info(t.get('no_concepts1', 'No hay conceptos disponibles para el Texto 1'))
+                            try:
+                                # Intentar crear DataFrame
+                                if (isinstance(analysis['key_concepts1'][0], list) and 
+                                    len(analysis['key_concepts1'][0]) == 2):
+                                    df1 = pd.DataFrame(analysis['key_concepts1'], 
+                                                      columns=['Concepto', 'Relevancia'])
+                                    st.dataframe(df1, use_container_width=True)
+                                else:
+                                    # Mostrar como lista simple
+                                    st.write(", ".join([str(item) for item in analysis['key_concepts1']]))
+                            except Exception as e:
+                                logger.error(f"Error mostrando conceptos 1: {str(e)}")
+                                st.error("Error al mostrar conceptos del Texto 1")
                         
+                        # Segunda columna: conceptos del texto 2 (si existen)
                         with col2:
                             st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-                            if 'key_concepts2' in analysis and analysis['key_concepts2']:
+                            if ('key_concepts2' in analysis and analysis['key_concepts2'] and 
+                                isinstance(analysis['key_concepts2'], list)):
                                 try:
-                                    # Intentar diferentes formatos de conceptos clave
-                                    if isinstance(analysis['key_concepts2'], list) and \
-                                       len(analysis['key_concepts2']) > 0:
-                                        # Verificar si es lista de listas (formato esperado)
-                                        if isinstance(analysis['key_concepts2'][0], list) and \
-                                           len(analysis['key_concepts2'][0]) == 2:
-                                            df2 = pd.DataFrame(analysis['key_concepts2'], 
-                                                             columns=['Concepto', 'Relevancia'])
-                                            st.dataframe(df2, use_container_width=True)
-                                        else:
-                                            # Es una lista simple
-                                            st.write(", ".join(str(c) for c in analysis['key_concepts2']))
+                                    # Intentar crear DataFrame
+                                    if (isinstance(analysis['key_concepts2'][0], list) and 
+                                        len(analysis['key_concepts2'][0]) == 2):
+                                        df2 = pd.DataFrame(analysis['key_concepts2'], 
+                                                          columns=['Concepto', 'Relevancia'])
+                                        st.dataframe(df2, use_container_width=True)
                                     else:
-                                        st.write(str(analysis['key_concepts2']))
+                                        # Mostrar como lista simple
+                                        st.write(", ".join([str(item) for item in analysis['key_concepts2']]))
                                 except Exception as e:
                                     logger.error(f"Error mostrando conceptos 2: {str(e)}")
-                                    st.error(t.get('error_concepts2', 'Error mostrando conceptos del Texto 2'))
+                                    st.error("Error al mostrar conceptos del Texto 2")
                             else:
-                                st.info(t.get('no_concepts2', 'No hay conceptos disponibles para el Texto 2'))
+                                st.info("No hay conceptos disponibles para el Texto 2")
                     
-                    # Mostrar gráficos si existen
-                    if has_graphs:
-                        st.markdown("---")  # Separador
-                        
-                        # Intentar mostrar cada gráfico con manejo de excepciones específico para cada uno
-                        for graph_key, graph_title in [
-                            ('graph1', t.get('graph1_title', 'Visualización del Texto 1')),
-                            ('graph2', t.get('graph2_title', 'Visualización del Texto 2')),
-                            ('combined_graph', t.get('combined_graph_title', 'Visualización Comparativa'))
-                        ]:
-                            if graph_key in analysis and analysis[graph_key]:
-                                st.subheader(graph_title)
-                                try:
-                                    image_data = analysis[graph_key]
-                                    
-                                    # Manejo según tipo de dato
-                                    if isinstance(image_data, bytes):
-                                        st.image(image_data, use_column_width=True)
-                                    elif isinstance(image_data, str):
-                                        try:
-                                            import base64
-                                            # Intentar diferentes formatos de base64
-                                            if image_data.startswith('data:image'):
-                                                # Formato Data URI
-                                                image_bytes = base64.b64decode(image_data.split(',')[1])
-                                            else:
-                                                # Base64 sin prefijo
-                                                image_bytes = base64.b64decode(image_data)
-                                            
-                                            st.image(image_bytes, use_column_width=True)
-                                        except Exception as decode_error:
-                                            logger.error(f"Error decodificando {graph_key}: {str(decode_error)}")
-                                            # Si no se puede decodificar, mostrar los primeros caracteres
-                                            st.error(f"Error decodificando imagen. Primeros caracteres: {image_data[:50]}...")
-                                    elif image_data is not None:
-                                        # Intentar como figura matplotlib
-                                        try:
-                                            st.pyplot(image_data)
-                                        except:
-                                            st.error(f"Formato de gráfico no reconocido para {graph_key}")
-                                except Exception as e:
-                                    logger.error(f"Error mostrando {graph_key}: {str(e)}")
-                                    st.error(t.get(f'error_{graph_key}', f'Error mostrando {graph_title}'))
+                    # Mostrar gráficos (si existen)
+                    has_graphs = False
+                    for graph_key, graph_title in [
+                        ('graph1', t.get('graph1_title', 'Visualización del Texto 1')),
+                        ('graph2', t.get('graph2_title', 'Visualización del Texto 2')),
+                        ('combined_graph', t.get('combined_graph_title', 'Visualización Comparativa'))
+                    ]:
+                        if graph_key in analysis and analysis[graph_key]:
+                            has_graphs = True
+                            st.markdown(f"### {graph_title}")
+                            try:
+                                image_data = analysis[graph_key]
+                                
+                                # Mostrar según el tipo de dato
+                                if isinstance(image_data, bytes):
+                                    st.image(image_data, use_column_width=True)
+                                elif isinstance(image_data, str):
+                                    # Intentar decodificar si es base64
+                                    try:
+                                        import base64
+                                        if image_data.startswith('data:image'):
+                                            image_bytes = base64.b64decode(image_data.split(',')[1])
+                                        else:
+                                            image_bytes = base64.b64decode(image_data)
+                                        st.image(image_bytes, use_column_width=True)
+                                    except Exception as decode_err:
+                                        logger.error(f"Error decodificando imagen: {str(decode_err)}")
+                                        st.error("Error decodificando imagen")
+                                elif hasattr(image_data, 'figure'):
+                                    # Si es un objeto matplotlib
+                                    st.pyplot(image_data)
+                                else:
+                                    st.error(f"Formato de gráfico no reconocido")
+                            except Exception as e:
+                                logger.error(f"Error mostrando gráfico {graph_key}: {str(e)}")
+                                st.error(f"Error mostrando {graph_title}")
                     
-                    # Si hay texto pero no hay visualizaciones, mostrar una nota
-                    if has_text and not has_graphs:
-                        st.markdown("---")
-                        st.info(t.get('no_visualizations', 'No hay visualizaciones disponibles para este análisis'))
+                    # Mensaje si no hay gráficos ni conceptos
+                    if not has_graphs and not has_concepts:
+                        st.warning("No se encontraron visualizaciones ni conceptos para este análisis")
                         
-                        # Opcionalmente mostrar un botón para regenerar el análisis (si implementas esa funcionalidad)
-                        #if st.button(t.get('regenerate_analysis', 'Regenerar análisis'), 
-                        #            key=f"btn_regenerate_{analysis_id}"):
-                        #    st.session_state.regenerate_analysis_id = analysis_id
-                        #    st.rerun()
+                        # Sugerir regenerar el análisis
+                        st.markdown("""
+                        Este análisis parece estar incompleto. Posibles razones:
+                        1. El proceso de análisis no terminó correctamente
+                        2. El texto era demasiado corto o no contenía suficiente información
+                        3. Hubo un error durante la generación de visualizaciones
+                        
+                        Considera realizar un nuevo análisis con más contenido textual.
+                        """)
 
             except Exception as e:
                 logger.error(f"Error procesando análisis individual: {str(e)}")
-                st.error(f"Error en análisis: {str(e)}")
+                st.error(f"Error en análisis #{i+1}: {str(e)}")
                 continue
 
     except Exception as e:
-        logger.error(f"Error mostrando análisis del discurso: {str(e)}")
+        logger.error(f"Error general mostrando análisis del discurso: {str(e)}")
         st.error(t.get('error_discourse', 'Error al mostrar análisis comparado de textos'))
-        
-        # Mostrar información de depuración para facilitar la solución de problemas
-        # No usar expander aquí para evitar problemas con contextos
         st.markdown("**Detalles del error:**")
         st.exception(e)
 
-
 #################################################################################   
 def display_chat_activities(username: str, t: dict):
     """