Update modules/studentact/student_activities_v2.py

modules/studentact/student_activities_v2.py

@@ -536,113 +536,178 @@ def display_semantic_activities(username: str, t: dict):
 
 ###################################################################################################
 
-def display_discourse_comparison(analysis: dict, t: dict):
+# Esta función debería reemplazar o complementar la actual display_discourse_activities
+def display_discourse_activities(username: str, t: dict):
     """
-    Muestra la comparación de análisis del discurso de manera minimalista pero efectiva.
-    Incluye tanto las tablas de conceptos como los gráficos disponibles.
+    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
     """
-    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
-    
-    # 1. Mostrar conceptos en columnas
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
-        if 'key_concepts1' in analysis and analysis['key_concepts1']:
-            try:
-                df1 = pd.DataFrame(analysis['key_concepts1'], 
-                                  columns=['Concepto', 'Relevancia'])
-                st.dataframe(df1)
-            except Exception as e:
-                # En caso de error, mostrar los datos sin procesar
-                st.write(analysis['key_concepts1'])
-        else:
-            st.info(t.get('no_concepts1', 'No hay conceptos disponibles'))
-    
-    with col2:
-        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-        if 'key_concepts2' in analysis and analysis['key_concepts2']:
+    try:
+        logger.info(f"Recuperando análisis del discurso para {username}")
+        analyses = get_student_discourse_analysis(username)
+        
+        if not analyses:
+            logger.info("No se encontraron análisis del discurso")
+            st.info(t.get('no_discourse_analyses', 'No hay análisis comparados de textos registrados'))
+            return
+
+        logger.info(f"Procesando {len(analyses)} análisis del discurso")
+        
+        for i, analysis in enumerate(analyses):
             try:
-                df2 = pd.DataFrame(analysis['key_concepts2'], 
-                                  columns=['Concepto', 'Relevancia'])
-                st.dataframe(df2)
-            except Exception as e:
-                # En caso de error, mostrar los datos sin procesar
-                st.write(analysis['key_concepts2'])
-        else:
-            st.info(t.get('no_concepts2', 'No hay conceptos disponibles'))
-    
-    # 2. Mostrar los gráficos si están disponibles
-    st.markdown("---")  # Separador
-    
-    # Verificar y mostrar gráficos
-    has_graphs = False
-    
-    # Gráfico 1
-    if 'graph1' in analysis and analysis['graph1']:
-        has_graphs = True
-        st.markdown(f"### {t.get('graph1_title', 'Gráfico Texto 1')}")
-        try:
-            # Intentar mostrar gráfico (asumiendo que es bytes o base64)
-            if isinstance(analysis['graph1'], bytes):
-                st.image(analysis['graph1'], use_column_width=True)
-            elif isinstance(analysis['graph1'], str):
-                import base64
-                try:
-                    image_bytes = base64.b64decode(analysis['graph1'])
-                    st.image(image_bytes, use_column_width=True)
-                except:
-                    st.error(t.get('error_decoding', 'Error decodificando imagen'))
-            else:
-                # Intentar como objeto matplotlib
-                st.pyplot(analysis['graph1'])
-        except Exception as e:
-            st.error(t.get('error_graph1', 'Error mostrando gráfico 1'))
-    
-    # Gráfico 2
-    if 'graph2' in analysis and analysis['graph2']:
-        has_graphs = True
-        st.markdown(f"### {t.get('graph2_title', 'Gráfico Texto 2')}")
-        try:
-            # Intentar mostrar gráfico (asumiendo que es bytes o base64)
-            if isinstance(analysis['graph2'], bytes):
-                st.image(analysis['graph2'], use_column_width=True)
-            elif isinstance(analysis['graph2'], str):
-                import base64
-                try:
-                    image_bytes = base64.b64decode(analysis['graph2'])
-                    st.image(image_bytes, use_column_width=True)
-                except:
-                    st.error(t.get('error_decoding', 'Error decodificando imagen'))
-            else:
-                # Intentar como objeto matplotlib
-                st.pyplot(analysis['graph2'])
-        except Exception as e:
-            st.error(t.get('error_graph2', 'Error mostrando gráfico 2'))
-    
-    # Gráfico combinado
-    if 'combined_graph' in analysis and analysis['combined_graph']:
-        has_graphs = True
-        st.markdown(f"### {t.get('combined_graph_title', 'Gráfico Comparativo')}")
-        try:
-            # Intentar mostrar gráfico (asumiendo que es bytes o base64)
-            if isinstance(analysis['combined_graph'], bytes):
-                st.image(analysis['combined_graph'], use_column_width=True)
-            elif isinstance(analysis['combined_graph'], str):
-                import base64
+                # 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:
-                    image_bytes = base64.b64decode(analysis['combined_graph'])
-                    st.image(image_bytes, use_column_width=True)
-                except:
-                    st.error(t.get('error_decoding', 'Error decodificando imagen'))
-            else:
-                # Intentar como objeto matplotlib
-                st.pyplot(analysis['combined_graph'])
-        except Exception as e:
-            st.error(t.get('error_combined_graph', 'Error mostrando gráfico comparativo'))
-    
-    # Mensaje si no hay gráficos
-    if not has_graphs:
-        st.info(t.get('no_graphs_available', 'No hay visualizaciones disponibles para este análisis.'))
+                    timestamp = datetime.fromisoformat(analysis['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)}")
+                    formatted_date = str(analysis.get('timestamp', 'Fecha desconocida'))
+                
+                # Crear título del expander
+                expander_title = f"{t.get('analysis_date', 'Fecha')}: {formatted_date}"
+                
+                # 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'])
+                    
+                    has_graphs = any(analysis.get(k) is not None for k in ['graph1', 'graph2', 'combined_graph'])
+                    
+                    # 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)
+                        with st.expander("Ver datos disponibles", expanded=False):
+                            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
+                    if has_key_concepts:
+                        col1, col2 = st.columns(2)
+                        
+                        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'))
+                        
+                        with col2:
+                            st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
+                            if 'key_concepts2' in analysis and analysis['key_concepts2']:
+                                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']))
+                                    else:
+                                        st.write(str(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'))
+                            else:
+                                st.info(t.get('no_concepts2', '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}'))
+                    
+                    # 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'))
+                        
+                        # 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()
+
+            except Exception as e:
+                logger.error(f"Error procesando análisis individual: {str(e)}")
+                st.error(f"Error en análisis: {str(e)}")
+                continue
+
+    except Exception as e:
+        logger.error(f"Error 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
+        with st.expander("Detalles del error", expanded=False):
+            st.exception(e)
 
 
 #################################################################################   
@@ -696,18 +761,3 @@ def display_chat_activities(username: str, t: dict):
         st.error(t.get('error_chat', 'Error al mostrar historial del chat'))
         
 #################################################################################        
-def display_discourse_comparison(analysis: dict, t: dict):
-    """Muestra la comparación de análisis del discurso"""
-    # Cambiado para usar "textos comparados" en la UI
-    st.subheader(t.get('comparison_results', 'Resultados de la comparación'))
-    
-    col1, col2 = st.columns(2)
-    with col1:
-        st.markdown(f"**{t.get('concepts_text_1', 'Conceptos Texto 1')}**")
-        df1 = pd.DataFrame(analysis['key_concepts1'])
-        st.dataframe(df1)
-    
-    with col2:
-        st.markdown(f"**{t.get('concepts_text_2', 'Conceptos Texto 2')}**")
-        df2 = pd.DataFrame(analysis['key_concepts2'])
-        st.dataframe(df2)